chrv-components 1.10.78 → 1.11.0

package/index.d.ts

@@ -1,5 +1,1419 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, EventEmitter, AfterViewChecked, AfterContentChecked, ElementRef, ViewContainerRef, QueryList, AfterContentInit, InjectionToken, Type } from '@angular/core';
+import { Router, UrlTree } from '@angular/router';
+import { MatDialogRef, MatDialogConfig } from '@angular/material/dialog';
+export * from '@angular/material/dialog';
+import * as _angular_forms from '@angular/forms';
+import { AbstractControl, ValidationErrors, ValidatorFn, AsyncValidatorFn, FormControl, FormGroup, ControlValueAccessor, NgControl, Validator } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Subject, Subscription, Observable, BehaviorSubject } from 'rxjs';
+import { MatAutocomplete } from '@angular/material/autocomplete';
+import { PaginationService, PaginationInstance } from 'ngx-pagination';
+export * from 'ngx-pagination';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import { HttpClient, HttpInterceptorFn, HttpEvent, HttpFeature } from '@angular/common/http';
+import * as _angular_animations from '@angular/animations';
+export * from 'chrv-pipes';
+export * from 'ngx-mask';
+
+interface Breadcrumb {
+    display: string;
+    link?: string;
+    callback?: Function;
+}
+declare class BreadcrumbComponent {
+    router: Router;
+    readonly crumbs: _angular_core.InputSignal<Breadcrumb[] | undefined>;
+    navigateTo: (uri: string, data?: any) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "app-chr-breadcrumb", never, { "crumbs": { "alias": "crumbs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type Color = 'primary' | 'primary-contrast' | 'secondary' | 'secondary-contrast' | 'tertiary' | 'tertiary-contrast' | 'warn' | 'warn-contrast' | 'error' | 'error-contrast' | 'black' | 'white' | 'none';
+declare const Colors: {
+    [key: string]: string;
+};
+declare function getTextColor(color?: Color): string;
+declare function getContrastTextColor(color: Color): string;
+declare function getBackgroundColor(color?: Color): string;
+declare function getContrastBackgroundColor(color: Color): never;
+declare function getBorderColor(color?: Color): string;
+declare function getContrastBorderColor(color?: Color): string;
+
+declare class ChrButtonComponent {
+    readonly display: _angular_core.InputSignal<string | undefined>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly click: _angular_core.InputSignal<Function | undefined>;
+    readonly clickWhileDisabled: _angular_core.InputSignal<Function | undefined>;
+    readonly color: _angular_core.InputSignal<Color>;
+    readonly textColor: _angular_core.InputSignal<Color | undefined>;
+    readonly flat: _angular_core.InputSignal<boolean>;
+    readonly predicate: _angular_core.InputSignal<boolean | undefined>;
+    readonly type: _angular_core.InputSignal<"none" | "responsive" | "table" | "full" | "fixed" | "small">;
+    readonly href: _angular_core.InputSignal<string | undefined>;
+    readonly target: _angular_core.InputSignal<"_blank" | "_parent" | "_self" | "_top" | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly tooltip: _angular_core.InputSignal<string | undefined>;
+    readonly tooltipPosition: _angular_core.InputSignal<"above" | "below" | "left" | "right" | "before" | "after" | undefined>;
+    constructor();
+    doClick: () => void;
+    getBackgroundColor: (color: Color) => string;
+    getTextColor: (color: Color) => string;
+    getWidth: () => "w-36" | "w-full" | "w-9" | "w-min";
+    getShadow: () => "" | "button-shadow";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrButtonComponent, "app-chr-button", never, { "display": { "alias": "display"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "click": { "alias": "click"; "required": false; "isSignal": true; }; "clickWhileDisabled": { "alias": "clickWhileDisabled"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; "flat": { "alias": "flat"; "required": false; "isSignal": true; }; "predicate": { "alias": "predicate"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ChrDeleteModalComponent {
+    dialogRef: MatDialogRef<ChrDeleteModalComponent, any>;
+    valid: boolean;
+    ngOnInit(): void;
+    cancel: () => void;
+    close: () => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrDeleteModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrDeleteModalComponent, "app-chr-delete-modal", never, {}, {}, never, never, true, never>;
+}
+
+interface IControlValidation {
+    rule: string;
+    validator?: (control: AbstractControl) => ValidationErrors | null;
+    key?: string;
+    value?: any;
+    display?: string;
+}
+declare function SyncValidatorToAsync(validator: ValidatorFn): AsyncValidatorFn;
+declare function getValidators(rules?: IControlValidation[]): ValidatorFn[];
+declare function getAsyncValidators(rules?: IControlValidation[]): AsyncValidatorFn[];
+declare function getSyncValidators(rules?: IControlValidation[]): ValidatorFn[];
+
+type InputType = 'text' | 'password' | 'textArea' | 'number' | 'date' | 'datetime' | 'searchSelect' | 'tagSelect' | 'color' | 'toggle' | 'file' | 'hidden';
+interface ISearchFilter {
+    display: string;
+    callback?: Function;
+    tooltip?: string;
+}
+interface IControl {
+    label?: string;
+    name: string;
+    span?: string;
+    width?: 'col' | 'row';
+    col?: number;
+    row?: number;
+    type: InputType;
+    accept?: string[];
+    debounceTime?: number;
+    value?: any;
+    data?: any[] | null;
+    icon?: string;
+    iconCallback?: Function;
+    iconCallbackDisabled?: boolean;
+    iconTooltip?: string;
+    fn?: (object: any) => string;
+    filters?: ISearchFilter[];
+    validations?: IControlValidation[];
+    addCallback?: ((entry: any, subject: Subject<any>) => any | null | void) | null;
+    editCallback?: ((entry: any, subject: Subject<any>) => any | null | void) | null;
+    removeCallback?: ((entry: any) => any | null | void) | null;
+    acceptText?: boolean;
+    multiple?: boolean;
+    /**
+     * Should the file be converted to base64 for sending
+     */
+    base64?: boolean;
+    autofocus?: boolean;
+}
+
+interface IFormSection {
+    title?: string;
+    controls: IControl[];
+}
+declare class ChrFormComponent implements OnInit {
+    private builder;
+    private changeDetector;
+    private element;
+    readonly sections: _angular_core.InputSignal<IFormSection[]>;
+    readonly controls: _angular_core.InputSignal<IControl[]>;
+    readonly validators: _angular_core.InputSignal<ValidatorFn | ValidatorFn[] | null>;
+    readonly valid: _angular_core.InputSignal<boolean>;
+    readonly validChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly model: _angular_core.InputSignal<any>;
+    readonly modelChange: _angular_core.OutputEmitterRef<any>;
+    readonly formDataChange: _angular_core.OutputEmitterRef<FormData>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly valuesChanges: _angular_core.OutputEmitterRef<any>;
+    readonly submit: _angular_core.InputSignal<Function | undefined>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    readonly debounceTime: _angular_core.InputSignal<number | null>;
+    readonly formChange: _angular_core.OutputEmitterRef<{
+        [key: string]: any;
+    }>;
+    readonly valueChanges: _angular_core.OutputEmitterRef<{
+        [name: string]: any;
+    }>;
+    readonly tabDisplay: _angular_core.InputSignal<boolean>;
+    formControls: {
+        [key: string]: FormControl;
+    };
+    /**
+     * The related ReactiveForm of the form group. This is exposed to allow form extension and usage of custom form controls while still maintaining centralised validation and validity
+     */
+    readonly form: _angular_core.InputSignal<FormGroup<any>>;
+    readonly formChanges: _angular_core.OutputEmitterRef<FormGroup<any> | null>;
+    private values;
+    private controlTypes;
+    private flattenedControls;
+    private flattenedShownControl;
+    private flattenedHiddenControls;
+    initialized: boolean;
+    constructor();
+    ngOnInit(): void;
+    private initModel;
+    private initValues;
+    private initControls;
+    private initListeners;
+    private hasRegularFile;
+    getEncType: () => string;
+    /**
+     * Methods that returns the FormControl for the given input. If no FormControl is found, return null.
+     * @param name input's name
+     * @returns the FormControl whose name matches the parameter
+     */
+    getControl: (name: string) => _angular_forms.AbstractControl<any, any> | null;
+    /**
+     * Focus the input for the user to start typing in.
+     * @param name input's name
+     */
+    focus: (name: string) => void;
+    /**
+     * Returns the value of the input whose name matches the parameter input.
+     * If no input name is provided, returns the value of the form.
+     * @param input name of the input
+     * @returns the value of the input
+     */
+    value: (input?: string) => any;
+    /**
+     * Returns the value of the input whose name matches the parameter input.
+     * If no input name is provided, returns the value of the form.
+     * @param input name of the input
+     * @returns the value of the input
+     */
+    getValue: (input?: string) => any;
+    /**
+     * Returns the validity of the input.
+     * If no input is provided, returns the validity of the form.
+     * @param input name of the input
+     * @returns
+     */
+    isValid: (input?: string) => boolean | undefined;
+    /**
+     * Update the value of a control WITHOUT triggering the modelChange event
+     * @param key input key (control name)
+     * @param value value to set
+     */
+    setValue: (key: string, value: any) => void;
+    /**
+     * Update the value of the form's model WITHOUT triggering the modelChange event
+     * @param model the model to set
+     */
+    set: (model: any) => void;
+    /**
+     * Updates the value of a control. This WILL trigger the modelChange event
+     * @param key input key (control name)
+     * @param value value to set
+     */
+    patchValue: (key: string, value: any) => void;
+    /**
+     * Updates the value of the form's model. This WILL trigger the modelChange event once for each input
+     * @param model model to set
+     */
+    patch: (model: any) => void;
+    /**
+     * Methods that checks the validity of each input of the form and updates their status. If the markAsTouched parameter si set to true, it will also mark the inputs as touched
+     * so that the validation errors may be displayed to the user.
+     * @param markAsTouched Boolean that describes whether or not the inputs of the form will be marked as touched.
+     */
+    checkValidity: (markAsTouched?: boolean) => void;
+    /**
+     * Here for compatibility. Same thing as checkValidity.
+     */
+    updateValueAndValidity: (markAsTouched?: boolean) => void;
+    /**
+     * Resets the form.
+     */
+    reset: () => void;
+    toFormData: () => FormData;
+    protected get: (control: IControl) => _angular_forms.AbstractControl<any, any> | null;
+    private setValue$;
+    private setModel$;
+    /**
+     * Triggers the submit method and pass the local values as its parameters. The local values will contain the values of every input. Not just those that match de model's property (ex: like those provided by the modelChanges event).
+     */
+    doSubmit: () => void;
+    protected log: (el: any) => void;
+    protected initializeControl: (control: IControl, formControl: FormControl) => void;
+    alert: (s: string) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrFormComponent, "app-chr-form", never, { "sections": { "alias": "sections"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; "isSignal": true; }; "validators": { "alias": "validators"; "required": false; "isSignal": true; }; "valid": { "alias": "valid"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submit": { "alias": "submit"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "tabDisplay": { "alias": "tabDisplay"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "validChange": "validChange"; "modelChange": "modelChange"; "formDataChange": "formDataChange"; "valuesChanges": "valuesChanges"; "formChange": "formChange"; "valueChanges": "valueChanges"; "formChanges": "formChanges"; }, never, never, true, never>;
+}
+
+declare class ChrBaseInputComponent implements OnInit, ControlValueAccessor, AfterViewInit, OnDestroy {
+    /**
+     * The label that will be shown to the user for this input.
+     */
+    readonly label: _angular_core.InputSignal<string | null>;
+    /**
+     * The type of the input. The BaseInput class is designed to be used for the basic text/number/password/hidden types. Any other kind of input would probably benefit of a custom component inheriting BaseInput.
+     */
+    readonly type: _angular_core.InputSignal<InputType>;
+    /**
+     * The id of the input.
+     */
+    readonly id: _angular_core.InputSignal<string | null>;
+    /**
+     * The name of the input. It's the model's property name or the key that will be set to the value object
+     */
+    readonly name: _angular_core.InputSignal<string | null>;
+    private _value;
+    get value(): any | null;
+    set value(value: any | null);
+    private valueSubject;
+    private valueSubscription;
+    /**
+     * The value change event. This will be triggered both by onChange and by onValueChange (they technically should not be fired together as onValueChange ends up calling onChange)
+     */
+    valueChanges: EventEmitter<any>;
+    /**
+     * Whether or not the input is required
+     */
+    protected required: boolean;
+    /**
+     * Span that will be shown under the input
+     */
+    readonly span: _angular_core.InputSignal<string | null>;
+    /**
+     * Name of the material icon that will be displayed
+     */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /**
+     * A callback function that will be triggered on the input's icon click with the current value of the input
+     */
+    readonly iconCallback: _angular_core.InputSignal<((value: any) => string | void) | null>;
+    /**
+     * Whether or not the icon's callback is enabled
+     */
+    readonly iconCallbackDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Tooltip that will be displayed when hovering the input's icon
+     */
+    readonly iconTooltip: _angular_core.InputSignal<string | null>;
+    /**
+     * Tooltip that will be displayed on hover
+     */
+    readonly tooltip: _angular_core.InputSignal<string | null>;
+    /**
+     * Debounce time that will be used by the input before throwing the new value event
+     */
+    readonly debounceTime: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * Validations that will be evaluated for the input. In the case of custom validator function, the return object needs to contain a key with the 'rule' and it's value needs to be 'true'
+     */
+    readonly validations: _angular_core.InputSignal<IControlValidation[]>;
+    /**
+     * Indicates whether or not this input is being used outside a ReactiveForm. Default is false. If this is false, the input will create it's own FormControl as to enable it's complex behaviors
+     */
+    readonly standalone: _angular_core.InputSignal<boolean>;
+    /**
+     * Indicates whether or not this input should try catching the focus on page load
+     */
+    readonly autofocus: _angular_core.InputSignal<boolean>;
+    /**
+     * Indicates whether or not this input should convert the file to base64 for it to be sent as part of the object.
+     * If this is false, the file won't be converted and will be sent as part as the regular form process.
+     * Default is true to allow full JS manipulation of files et upload progress report.
+     */
+    readonly base64: _angular_core.InputSignal<boolean>;
+    private _disabled;
+    /**
+     * Getter and setter that allow the control of the FormControl's state from the template
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Whether or not the input starts as disabled. This can then be changed through the form control.
+     */
+    isDisabled: boolean;
+    /**
+     * Array of string representing the input's siblings' FormControl's name. This will be used to trigger the validity of the siblings when this input's value changes
+     */
+    readonly siblings: _angular_core.InputSignal<string[]>;
+    onChange: any;
+    onTouch: any;
+    /**
+     * Whether or not the input is touched
+     */
+    isTouched: boolean;
+    /**
+     * The NgControl associated with this input
+     */
+    protected control: NgControl | null;
+    /**
+     * The validity status of the related FormControl
+     */
+    isValid: boolean | null;
+    /**
+     * Every child should either call super(ngControl) or implement the logic for the input to bind the control to the FormControl.
+     * @param ngControl the FormControl binded to this CVA
+     */
+    constructor();
+    /**
+     * A callback method that is invoked immediately after the default change detector has checked the directive's data-bound properties for the first time, and before any of the view or content children have been checked. It is invoked only once when the directive is instantiated.
+     * In the case of the BaseInput class, this methods also subscribes to the onValueChange's subject as to register the debounce time.
+     *
+     * To use in any component inheriting the BaseInput Class, please call super.ngOnInit() at any point within the overriden ngOnInit() method.
+     */
+    ngOnInit(): void;
+    /**
+     * A callback method that is invoked immediately after Angular has completed initialization of a component's view. It is invoked only once when the view is instantiated.
+     *
+     * To use in any component inheriting the BaseInput Class, please call super.ngAfterViewInit() at any point within the overriden ngAfterViewInit() method.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * A callback method that performs custom clean-up, invoked immediately before a directive, pipe, or service instance is destroyed.
+     * In the case of the BaseInput class, this methods also unsubscribe to the onValueChange's subject as to avoid leaving a stray observable.
+     *
+     * To use in any component inheriting the BaseInput Class, please call super.ngOnDestroy() at any point within the overriden ngOnDestroy() method.
+     */
+    ngOnDestroy(): void;
+    /**
+     * A method that returns the input's value. If it's linked to a formcontrol returns the formcontrol's value otherwise the local value
+     * @returns value any
+     */
+    getValue: () => any;
+    /**
+     * A method that can be used instead of onChange(value). It will pass the new value to an observable that will in turn add a debounce time then call the onchange function.
+     *
+     * In short, using this method instead of onChange will add a debounce time.
+     * @param value The new value of the input
+     * @returns the value observable
+     */
+    onValueChange: (value: any) => Subscription;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    protected updateValueAndValidity: () => void;
+    /**
+     * Despite it's name, this method returns a single validation error's display (even if there are multiple). And that is the first error found.
+     * @returns display of the last error
+     */
+    protected getLastError: () => string | null;
+    /**
+     * Returns a boolean describing whether or not the control is required
+     * @returns
+     */
+    protected isControlRequired: () => boolean;
+    /**
+     * Returns the current error status of the input.
+     * @returns
+     */
+    protected hasError: () => boolean;
+    private configureDebouncing;
+    private configureTouchBehavior;
+    private configureValidityReplication;
+    private configureFormControl;
+    private buildFormControl;
+    protected doCallback: () => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrBaseInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrBaseInputComponent, "chr-base-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "span": { "alias": "span"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconCallback": { "alias": "iconCallback"; "required": false; "isSignal": true; }; "iconCallbackDisabled": { "alias": "iconCallbackDisabled"; "required": false; "isSignal": true; }; "iconTooltip": { "alias": "iconTooltip"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "validations": { "alias": "validations"; "required": false; "isSignal": true; }; "standalone": { "alias": "standalone"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "base64": { "alias": "base64"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "siblings": { "alias": "siblings"; "required": false; "isSignal": true; }; }, { "valueChanges": "valueChanges"; }, never, never, true, never>;
+}
+
+declare class ChrColorInputComponent extends ChrBaseInputComponent implements OnInit, AfterViewInit, OnDestroy {
+    constructor();
+    parseColor: (event: string) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrColorInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrColorInputComponent, "chr-color-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChrDateInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    private datePipe;
+    constructor();
+    writeValue(obj: any): void;
+    ngOnInit(): void;
+    onInputChange: (value: any) => void;
+    parseDate: (event: string) => Date | null;
+    dateToString: (value: Date) => string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrDateInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrDateInputComponent, "chr-date-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChrDatetimeInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    private datePipe;
+    constructor();
+    writeValue(obj: any): void;
+    ngOnInit(): void;
+    onInputChange: (value: any) => void;
+    parseDate: (event: string) => Date | null;
+    dateToString: (value: Date) => string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrDatetimeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrDatetimeInputComponent, "chr-datetime-input", never, {}, {}, never, never, true, never>;
+}
+
+interface IFile {
+    name?: string;
+    file?: File | null;
+    url?: string | null;
+    data?: string | null;
+    extension?: string | null;
+}
+
+declare class ChrFileInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    private fileService;
+    private toastService;
+    /**
+     * An array of string that contains each type that should be accepted by the input
+     */
+    readonly accept: _angular_core.InputSignal<string[]>;
+    /**
+     * Whether or not the input should allow multiple file selection
+     */
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    valueDisplay: string | null;
+    /**
+     * Whether or not the progress bar that display a file's conversion progress will be editable by the user
+     */
+    readonly editable: _angular_core.InputSignal<boolean>;
+    errors: {
+        [index: number]: boolean;
+    } | null;
+    files: Observable<{
+        progress: number;
+        file?: IFile;
+    }>[];
+    constructor();
+    writeValue(obj: any | any[]): void;
+    ngOnInit(): void;
+    protected onFileChange: (event: any) => void;
+    protected acceptToString: () => string;
+    protected getToAccept: () => string;
+    protected changeFileName: (event: any, file?: IFile) => void;
+    protected openFile: (index: number, file?: IFile) => void;
+    protected removeFile: (index: number, file?: IFile) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrFileInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrFileInputComponent, "chr-file-input", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ChrTextareaInputComponent extends ChrBaseInputComponent implements OnInit, AfterViewInit, OnDestroy, AfterViewChecked, AfterContentChecked {
+    readonly input: _angular_core.Signal<ElementRef<any> | null | undefined>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngAfterContentChecked(): void;
+    ngAfterViewChecked(): void;
+    resize: (textArea?: HTMLTextAreaElement) => void;
+    preventSubmit: (event: Event) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrTextareaInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrTextareaInputComponent, "chr-textarea-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChrToggleInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    constructor();
+    toggle: (event: any) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrToggleInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrToggleInputComponent, "chr-toggle-input", never, {}, {}, never, never, true, never>;
+}
+
+interface IInputSearchFilter {
+    display: string;
+    callback?: Function;
+    tooltip?: string;
+}
+declare class ChrSearchSelectComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    predicate: boolean;
+    filteredModelOptions?: Observable<any>;
+    private values;
+    readonly autocomplete: _angular_core.Signal<MatAutocomplete>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly data: _angular_core.InputSignal<any[] | null>;
+    readonly display: _angular_core.InputSignal<((entry: any) => string) | undefined>;
+    readonly filters: _angular_core.InputSignal<IInputSearchFilter[] | null>;
+    /**
+     * Callback that will be called BEFORE the value is added with the selected value passed as parameter.
+     * If this callback returns null, the entry will NOT be added.
+     * This lets you update the value before it's added.
+     */
+    readonly addCallback: _angular_core.InputSignal<((entry: any, subject: Subject<any>) => any | null | void) | null | undefined>;
+    private addSubject;
+    /**
+     * Indicate if the input accepts raw text or if the requires the selection to be made from the search list.
+     * This defaults to false.
+     * If there are neither data nor display function, this defaults to true.
+     */
+    readonly acceptText: _angular_core.InputSignal<boolean | null>;
+    protected filterIndex: _angular_core.WritableSignal<number>;
+    protected overrideShowResults: boolean;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Reset the input's text and sets the value to null as to invalidate the input
+     */
+    protected reset: () => void;
+    /**
+     * Set's the input's text's value and set the value to null as to invalidate the input
+     * @param input text input
+     */
+    protected inputChange: (input: string) => void;
+    /**
+     * Returns the model's textual value using the display function display passed as callback. If there is no display, returns the model's default string value.
+     * @param model the data's entry for which we want the textual value
+     * */
+    protected getModelDisplay: (model: any) => any;
+    /**
+     * Start filtering the autocomplete's list based on the input's textual value
+     */
+    protected registerFilters: () => void;
+    /**
+     * Increments the filter and focus the filtered input. It also sets the value to null as to force the user to choose a filtered value.
+     * @param input the input in which the user should type
+     */
+    protected increment: (input: any) => void;
+    protected voidd: () => void;
+    protected enableShowPanel: (input: any) => void;
+    protected disableShowPanel: () => void;
+    protected addFromText: (event: any) => void;
+    private _filterModel;
+    private _doFilterModelInt;
+    private _doFilterModelString;
+    private _filterValues;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrSearchSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrSearchSelectComponent, "app-chr-search-select, [app-chr-search-select]", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "addCallback": { "alias": "addCallback"; "required": false; "isSignal": true; }; "acceptText": { "alias": "acceptText"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ChrTagSelectComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    predicate: boolean;
+    readonly autocomplete: _angular_core.Signal<MatAutocomplete>;
+    protected overrideShowResults: boolean;
+    filteredModelOptions?: Observable<any>;
+    protected textInputValue: _angular_core.WritableSignal<string>;
+    private values;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly data: _angular_core.InputSignal<any[] | null>;
+    readonly display: _angular_core.InputSignal<((entry: any) => string) | undefined>;
+    readonly filters: _angular_core.InputSignal<IInputSearchFilter[] | null>;
+    /**
+     * Callback that will be called on click of a chips. The entry will be passed as parameter.
+     * If this callback returns null, the entry will be removed.
+     * If this callback returns a different value (by reference (ex: different object)) the entry will be replaced by the new value.
+     */
+    readonly editCallback: _angular_core.InputSignal<((entry: any, subject: Subject<any>) => any | null | void) | null | undefined>;
+    private editSubject;
+    /**
+     * Callback that will be called BEFORE the value is added with the selected value passed as parameter.
+     * If this callback returns null, the entry will NOT be added.
+     * This lets you update the value before it's added.
+     */
+    readonly addCallback: _angular_core.InputSignal<((entry: any, subject: Subject<any>) => any | null | void) | null | undefined>;
+    private addSubject;
+    /**
+     * Callback that will be called during the removal of the value. This will be called with the deleted value passed as parameter.
+     */
+    readonly removeCallback: _angular_core.InputSignal<((entry: any) => any | null | void) | null>;
+    /**
+     * Indicate if the input accepts raw text or if the requires the selection to be made from the search list.
+     * This defaults to false.
+     * If there are neither data nor display function, this defaults to true.
+     */
+    readonly acceptText: _angular_core.InputSignal<boolean | null>;
+    constructor();
+    protected filterIndex: _angular_core.WritableSignal<number>;
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    protected reset: () => void;
+    protected inputChange: (input: string) => void;
+    protected getModelDisplay: (model: any) => any;
+    protected addFromText: (event: any) => void;
+    protected add: (event: any) => void;
+    protected edit: (entry: any) => void;
+    protected remove(value: any): void;
+    protected registerFilters: () => void;
+    protected increment: (input: any) => void;
+    protected void: () => void;
+    protected enableShowPanel: (input: any) => void;
+    protected disableShowPanel: () => void;
+    protected getTooltip: () => "" | "Appuyez sur 'Enter' pour ajouter la valeur du champs à la liste" | "Entrez un espace pour voir les choix disponibles";
+    private _filterModel;
+    private _doFilterModelInt;
+    private _doFilterModelString;
+    private _filterValues;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrTagSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrTagSelectComponent, "app-chr-tag-select, [app-chr-tag-select]", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "editCallback": { "alias": "editCallback"; "required": false; "isSignal": true; }; "addCallback": { "alias": "addCallback"; "required": false; "isSignal": true; }; "removeCallback": { "alias": "removeCallback"; "required": false; "isSignal": true; }; "acceptText": { "alias": "acceptText"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type Alignment = 'left' | 'center' | 'right';
+declare const Aligments: {
+    [key: string]: string;
+};
+interface IChips {
+    display: string;
+    name: string;
+    callback: (entry: any) => string | boolean;
+    textColor?: Color;
+    backgroundColor?: Color;
+}
+interface IColumn {
+    display: string;
+    alignment?: 'left' | 'center' | 'right';
+    chips?: IChips[];
+    properties?: string[];
+    callback?: Function;
+    date?: string;
+    isLink?: boolean;
+    linkStaticUrl?: string;
+}
+interface IComputedRow {
+    columns: IComputedColumn[];
+}
+interface IComputedColumn {
+    label?: string;
+    value?: any;
+    callback?: Function;
+    alignment?: 'left' | 'center' | 'right';
+    after?: string;
+}
+interface IAction {
+    display?: string;
+    icon?: string;
+    callback: Function;
+    disabled?: boolean;
+    disabledCallback?: Function;
+    color: Color;
+}
+declare class ChrTableComponent implements OnInit, AfterViewInit {
+    private _date;
+    private dataService;
+    private changeDetector;
+    readonly computedRows: _angular_core.InputSignal<IComputedRow[] | undefined>;
+    readonly columns: _angular_core.InputSignal<IColumn[] | undefined>;
+    private _data;
+    get data(): any[] | null;
+    set data(value: any[] | null);
+    readonly actions: _angular_core.InputSignal<IAction[]>;
+    readonly isAsc: _angular_core.InputSignal<boolean>;
+    readonly isAscChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly sortBy: _angular_core.InputSignal<string[] | undefined>;
+    readonly sortByChange: _angular_core.OutputEmitterRef<string[]>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly pageSizeChange: _angular_core.OutputEmitterRef<number>;
+    readonly currentPage: _angular_core.InputSignal<number>;
+    readonly currentPageChange: _angular_core.OutputEmitterRef<number>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly selection: _angular_core.InputSignal<any[]>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<any[]>;
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<Color>;
+    readonly textColor: _angular_core.InputSignal<Color>;
+    private _page;
+    currentProperty: any | null;
+    currentText: string | null;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    protected emitIsAsc(isAsc: any): void;
+    protected emitSortBy(sortBy: any): void;
+    protected emitPageSize(pageSize: any): void;
+    protected emitCurrentPage(currentPage: any): void;
+    protected getProperty: (entry: any, properties?: any[]) => any;
+    protected getText: (property: any, column: IColumn) => any;
+    protected select: (entry: any, event: MouseEvent) => void;
+    getSelection: () => any[];
+    setSelection: (data: any[]) => void;
+    protected contains: (entry: any) => boolean;
+    protected getIsAsc: () => boolean;
+    protected getSortBy: () => string[] | undefined;
+    protected getTextColor: (color?: Color) => string;
+    protected getBackgroundColor: (color?: Color) => string;
+    protected getContrastTextColor: (color?: Color) => string;
+    protected getBorderColor: (color?: Color) => string;
+    protected getAlignment: (alignment?: Alignment) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrTableComponent, "app-chr-table, [app-chr-table]", never, { "computedRows": { "alias": "computedRows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "isAsc": { "alias": "isAsc"; "required": false; "isSignal": true; }; "sortBy": { "alias": "sortBy"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; }, { "isAscChange": "isAscChange"; "sortByChange": "sortByChange"; "pageSizeChange": "pageSizeChange"; "currentPageChange": "currentPageChange"; "selectionChange": "selectionChange"; }, never, ["*"], true, never>;
+}
+
+type TColumn = {
+    /**
+     * Nom de la colonne
+     */
+    display: string;
+    /**
+     * Sélecteur qui représente la propriété ciblée. Ex: 'obj.id'.
+     */
+    properties?: string;
+    /**
+     * Méthode callback qui sera appelée avec la valeur de la propriété cible.
+     * Elle est utilisée pour apporter un traitement personnalisé à la valeur.
+     * @param value valeur de la propriété cible
+     * @returns
+     */
+    callback?: (value: any | null | undefined) => string;
+    /**
+     * Type de la colonne: lien, chips, input, date, default
+     */
+    type?: TColumnType;
+    /**
+     * Format de la date pour les colonnes de type date
+     */
+    format?: string;
+    /**
+     * Url de base pour les colonnes de type lien
+     */
+    url?: string;
+    /**
+     * Type d'input pour les colonnes de type input
+     */
+    inputType?: 'text' | 'number' | 'password' | 'date' | 'datetime' | 'file' | 'color' | 'toggle';
+    /**
+     * Règles de validations pour les colonnes de type input
+     */
+    validations?: IControlValidation[];
+    /**
+     * Chips disponibles pour les colonnes de type chips
+     */
+    chips?: {
+        [key: string]: IChip;
+    };
+    /**
+     * Méthode callback qui sera avec la valeur de la propriété cible.
+     * Elle est utilisée comme clef pour sélectionner quel chips afficher
+     * @param entry
+     * @returns
+     */
+    chipsCallback?: (entry: any) => string;
+};
+interface IChip {
+    /**
+     * Le text qui sera affiché dans le chips
+     */
+    display: string;
+    /**
+     * La couleur du background du chips
+     */
+    color: Color;
+}
+type TColumnType = 'link' | 'chips' | 'input' | 'date' | 'default';
+declare class ChrDataTable {
+    private dataService;
+    private changeDetector;
+    /**
+     * Data to display.
+     * @see If it's piped with | Async, please note that the input column may not work as expected
+     */
+    data: _angular_core.InputSignal<any[]>;
+    /**
+     * Whether or not the table will show a column with a checkbox to select entries. Default is false
+     */
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    /**
+     * The selected entries
+     */
+    readonly selection: _angular_core.ModelSignal<any[]>;
+    /**
+     * The table's action column definition
+     */
+    readonly actions: _angular_core.InputSignal<IAction[] | undefined>;
+    /**
+     * Wheter or not the current sort is ascendant. Default is true
+     */
+    readonly isAsc: _angular_core.ModelSignal<boolean>;
+    /**
+     * The property by which the data will be sorted
+     */
+    readonly sortBy: _angular_core.ModelSignal<string | undefined>;
+    /**
+     * The page size for the table. Default is 20
+     */
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    /**
+     * The current page of the table. Default is 1
+     */
+    readonly currentPage: _angular_core.ModelSignal<number>;
+    /**
+     * The ID of the table. It's used to persist page size and currentpage when the user change pages
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The color to use for the table's header
+     */
+    readonly color: _angular_core.InputSignal<Color | undefined>;
+    /**
+     * The table's columns definitions
+     */
+    readonly columns: _angular_core.InputSignal<TColumn[]>;
+    ngOnInit(): void;
+    protected emitIsAsc(isAsc: any): void;
+    protected emitSortBy(sortBy: any): void;
+    protected emitPageSize(pageSize: any): void;
+    protected emitCurrentPage(currentPage: any): void;
+    protected getNestedProperty(obj: any, path?: string): any;
+    protected select: (entry: any | any[], event: MouseEvent) => void;
+    getSelection: () => any[];
+    setSelection: (data: any[]) => void;
+    protected contains: (entry: any) => boolean;
+    updateModel: (entry: any, properties: string, value: {
+        key: any;
+    }) => void;
+    protected getTextColor: (color?: Color) => string;
+    protected getBackgroundColor: (color?: Color) => string;
+    protected getContrastTextColor: (color?: Color) => string;
+    protected getBorderColor: (color?: Color) => string;
+    protected sort: (properties?: string) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrDataTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrDataTable, "chr-table", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "isAsc": { "alias": "isAsc"; "required": false; "isSignal": true; }; "sortBy": { "alias": "sortBy"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "isAsc": "isAscChange"; "sortBy": "sortByChange"; "pageSize": "pageSizeChange"; "currentPage": "currentPageChange"; }, never, never, true, never>;
+}
+
+declare class ChrNiceFileInputComponent extends ChrFileInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrNiceFileInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrNiceFileInputComponent, "chr-nice-file-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChrSearchbarComponent {
+    readonly model: _angular_core.InputSignal<string | null | undefined>;
+    readonly modelChange: _angular_core.OutputEmitterRef<string>;
+    readonly placeholder: _angular_core.InputSignal<string | null | undefined>;
+    readonly label: _angular_core.InputSignal<string | null | undefined>;
+    searchBy: FormControl<string | null>;
+    constructor();
+    emit(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrSearchbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrSearchbarComponent, "app-chr-searchbar", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "modelChange": "modelChange"; }, never, never, true, never>;
+}
+
+declare class ChrPaginatorComponent implements OnInit, AfterViewInit, AfterContentChecked {
+    service: PaginationService;
+    private cookieService;
+    private dataService;
+    private changeDetector;
+    page: _angular_core.InputSignal<number>;
+    pageChange: _angular_core.OutputEmitterRef<number>;
+    pageSize: _angular_core.InputSignal<number>;
+    pageSizeChange: _angular_core.OutputEmitterRef<number>;
+    instance?: PaginationInstance;
+    dataSize: _angular_core.Signal<number>;
+    currentlyShownSize: _angular_core.Signal<number>;
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    readonly allowSizeChange: _angular_core.InputSignal<string | boolean>;
+    readonly pageSizeForm: _angular_core.Signal<ChrFormComponent | null | undefined>;
+    ngAfterContentChecked(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    previous: () => void;
+    next: () => void;
+    setPage: (page: number) => void;
+    setPageEventHandler: (event: any) => void;
+    isFirstPage: () => boolean;
+    setPageSize: (pageSize: number) => void;
+    setPageSizeEventHandler: (event: any) => void;
+    isLastPage: () => boolean;
+    lastPage: () => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrPaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrPaginatorComponent, "app-chr-paginator", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "allowSizeChange": { "alias": "allowSizeChange"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * This should only be used as a directive
  */
-/// <amd-module name="chrv-components" />
-export * from './public-api';
+declare class ChrTableHeaderCellComponent {
+    private changeDetector;
+    readonly display: _angular_core.InputSignal<string | undefined>;
+    readonly column: _angular_core.InputSignal<string[] | undefined>;
+    readonly alignment: _angular_core.InputSignal<string | undefined>;
+    readonly isAsc: _angular_core.InputSignal<boolean>;
+    readonly isAscChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly sortBy: _angular_core.InputSignal<string[] | undefined>;
+    readonly sortByChange: _angular_core.OutputEmitterRef<string[]>;
+    orderBy: (column?: string[]) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrTableHeaderCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrTableHeaderCellComponent, "app-chr-table-header-cell, [app-chr-table-header-cell]", never, { "display": { "alias": "display"; "required": false; "isSignal": true; }; "column": { "alias": "column"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "isAsc": { "alias": "isAsc"; "required": false; "isSignal": true; }; "sortBy": { "alias": "sortBy"; "required": false; "isSignal": true; }; }, { "isAscChange": "isAscChange"; "sortByChange": "sortByChange"; }, never, ["*"], true, never>;
+}
+
+declare class ChrCheckboxComponent {
+    checked: boolean;
+    readonly type: _angular_core.InputSignal<"success" | "info">;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly change: _angular_core.OutputEmitterRef<{
+        checked: boolean;
+    }>;
+    check(end: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrCheckboxComponent, "app-chr-checkbox", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+declare class ChrSeparatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrSeparatorComponent, "app-chr-separator", never, {}, {}, never, never, true, never>;
+}
+
+declare class DecimalValidatorDirective implements Validator {
+    readonly amount: _angular_core.InputSignal<number | undefined>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DecimalValidatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DecimalValidatorDirective, "[app-decimal]", never, { "amount": { "alias": "amount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DecimalValidatorDirective>;
+}
+declare function decimal(amount: number): ValidatorFn;
+
+declare class MaxDateValidatorDirective implements Validator {
+    readonly date: _angular_core.InputSignal<Date | undefined>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaxDateValidatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MaxDateValidatorDirective, "[app-max-date]", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MaxDateValidatorDirective>;
+}
+declare function maxDate(date: Date): ValidatorFn;
+
+declare class TypeValidatorDirective implements Validator {
+    readonly type: _angular_core.InputSignal<string | undefined>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeValidatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TypeValidatorDirective, "[app-type]", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TypeValidatorDirective>;
+}
+declare function type(type: string): ValidatorFn;
+
+interface ILiveUpdateMessage {
+    status: LiveUpdateStatus;
+    message?: string | null;
+}
+declare enum LiveUpdateStatus {
+    Info = 0,
+    Warning = 1,
+    Error = 2,
+    End = 3
+}
+declare const DEFAULTLIVEUPDATEMESSAGE: ILiveUpdateMessage;
+declare const DefaultLiveUpdateMessage: ILiveUpdateMessage;
+
+declare class LoaderService {
+    private is_loading;
+    private is_loading$;
+    private requestStatckSize;
+    constructor();
+    setLoading: (is: boolean) => void;
+    isLoading: () => boolean;
+    isLoadingAsync: () => rxjs.Observable<boolean>;
+    getStackSize: () => number;
+    incrementStackSize: () => number;
+    decrementStackSize: () => number;
+    setStackSize: (value: number) => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoaderService>;
+}
+
+declare class LiveUpdateService {
+    private dataService;
+    private _hubUrl;
+    private _connection;
+    private _xsrf;
+    private _xsrfHeader;
+    private _message;
+    private _update;
+    constructor();
+    initConnection: () => Observable<void>;
+    onUpdate(): Observable<string>;
+    closeConnection(): Observable<void>;
+    getMessage(): Observable<ILiveUpdateMessage>;
+    getHubUrl: () => string | null;
+    private pushMessage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LiveUpdateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LiveUpdateService>;
+}
+
+declare class ChrSpinnerComponent implements OnInit {
+    loader: LoaderService;
+    liveUpdate: LiveUpdateService;
+    private changeDetector;
+    message: ILiveUpdateMessage;
+    ngOnInit(): void;
+    display: (message: ILiveUpdateMessage | null) => string | null | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrSpinnerComponent, "app-chr-spinner", never, {}, {}, never, never, true, never>;
+}
+
+interface Toast {
+    type: "error" | "success" | "warning";
+    message: string;
+    duration?: number;
+}
+declare class ToastService {
+    private toastQueue;
+    private currentToastSubject;
+    currentToast$: Observable<Toast | null>;
+    private toastCloseSubject;
+    private default_duration;
+    constructor();
+    current: () => Observable<Toast | null>;
+    next: () => void;
+    setSuccess(message?: string, time?: number): void;
+    setError(message: string, time?: number): void;
+    setWarning(message: string, time?: number): void;
+    private set;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
+}
+
+declare class ChrToastComponent {
+    toastService: ToastService;
+    readonly topmargin: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrToastComponent, "app-chr-toast", never, { "topmargin": { "alias": "topmargin"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface IDefaultDialogConfig extends MatDialogConfig<any> {
+    config?: MatDialogConfig<any>;
+    title: string;
+    text: string;
+    close?: string;
+    actions?: IAction[];
+}
+interface DialogConfig {
+    _config: {
+        title: string;
+        text: string;
+        close: string;
+        actions: IAction[];
+    };
+}
+declare class ChrDefaultModalComponent {
+    dialogRef: MatDialogRef<ChrDefaultModalComponent, any>;
+    config: DialogConfig;
+    private sanitizer;
+    valid: boolean;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly text: _angular_core.InputSignal<string | undefined>;
+    readonly actions: _angular_core.InputSignal<IAction[] | undefined>;
+    readonly close: _angular_core.InputSignal<string | undefined>;
+    protected html: SafeHtml | null;
+    constructor();
+    ngOnInit(): void;
+    closeModal: (callback?: Function) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrDefaultModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrDefaultModalComponent, "app-chr-default-modal", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "close": { "alias": "close"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ChrModalComponent {
+    dynamicContent: ViewContainerRef;
+    /**
+     * Indique si le modal est ouvert ou fermé.
+     * @default false
+     */
+    isOpen: _angular_core.InputSignal<boolean>;
+    /**
+     * Indique si le modal doit se fermer lorsque l'utilisateur clique sur le fond.
+     * @default true
+     */
+    closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    /**
+     * Indique si le modal doit se fermer lorsque l'utilisateur appuie sur la touche Échap.
+     * @default true
+     */
+    closeOnEscape: _angular_core.InputSignal<boolean>;
+    /**
+     * Événement émis lorsque le modal doit être fermé.
+     * @default undefined
+     */
+    close: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Largeur du modal en pourcentage de la largeur de la fenêtre.
+     * @default 50
+     */
+    width: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Hauteur du modal en pourcentage de la hauteur de la fenêtre.
+     * @default 50
+     */
+    height: _angular_core.InputSignal<number | undefined>;
+    getDynamicContentContainer(): ViewContainerRef;
+    onBackdropClick(): void;
+    onModalClick(event: Event): void;
+    onEscapeKey(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChrModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChrModalComponent, "chr-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+
+declare class InlineSvgComponent implements OnInit {
+    private http;
+    private sanitizer;
+    private el;
+    src: _angular_core.InputSignal<string | undefined>;
+    class: _angular_core.InputSignal<string | undefined>;
+    svgContent: _angular_core.WritableSignal<string>;
+    height: _angular_core.InputSignalWithTransform<string, string | number>;
+    width: _angular_core.InputSignalWithTransform<string, string | number>;
+    constructor(http: HttpClient, sanitizer: DomSanitizer, el: ElementRef);
+    ngOnInit(): void;
+    transformWidth(value: number | string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineSvgComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InlineSvgComponent, "chr-inline-svg", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TabComponent {
+    label: _angular_core.InputSignal<string>;
+    active: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "chr-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TabGroupComponent {
+    tabs: QueryList<TabComponent>;
+    protected selectedIndex: _angular_core.WritableSignal<number>;
+    color: _angular_core.InputSignal<"primary" | "secondary" | "tertiary" | undefined>;
+    fade: _angular_core.InputSignal<boolean>;
+    ngAfterContentInit(): void;
+    selectTab: (index: number) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabGroupComponent, "chr-tab-group", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "fade": { "alias": "fade"; "required": false; "isSignal": true; }; }, {}, ["tabs"], ["chr-tab"], true, never>;
+}
+
+declare class CarouselComponent implements AfterContentInit, AfterViewInit {
+    private platformId;
+    containerRef: ElementRef;
+    onResize(): void;
+    protected initialized: BehaviorSubject<boolean>;
+    protected resizeEvent: BehaviorSubject<void>;
+    protected resize: Observable<void>;
+    protected items: _angular_core.WritableSignal<HTMLElement[]>;
+    protected pages: _angular_core.WritableSignal<number>;
+    /**
+     * Whether the selectors should be stacked on top of the carousel body.
+     * Defaults to true.
+     */
+    stackSelectors: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the buttons should be stacked on top of the carousel body.
+     * Defaults to true.
+     */
+    stackButtons: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the carousel should display only one item per page or be dynamic.
+     * If set to true, the carousel will always show one item per page.
+     */
+    singleItemPerPage: _angular_core.InputSignal<boolean>;
+    currentIndex: _angular_core.WritableSignal<number>;
+    /**
+     * Whether to show the selectors.
+     * Defaults to 'Roboto, sans-serif'.
+     */
+    showSelectors: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to show the next and previous buttons.
+     * Defaults to true.
+     */
+    showButtons: _angular_core.InputSignal<boolean>;
+    /**
+     * An output event that emits when the user clicks the next button.
+     */
+    onNext: _angular_core.OutputEmitterRef<number>;
+    /**
+     * An output event that emits when the user clicks the previous button.
+     */
+    onPrevious: _angular_core.OutputEmitterRef<number>;
+    /**
+     * An output event that emits when the user selects a slide with the selector.
+     */
+    onChange: _angular_core.OutputEmitterRef<number>;
+    /**
+     * An observable that emits a value every `timer` seconds.
+     * This is used to automatically advance the carousel.
+     */
+    interval: Observable<number> | null;
+    constructor(platformId: Object);
+    /**
+     * The time in seconds before the next slide is shown.
+     * If set to 0, the carousel will not auto-advance.
+     */
+    timer: _angular_core.InputSignal<number>;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    next: (emit?: boolean) => void;
+    prev: () => void;
+    select: (index: number) => void;
+    updatePages: () => void;
+    arrayFrom: (length: number) => number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselComponent, "chr-carousel", never, { "stackSelectors": { "alias": "stackSelectors"; "required": false; "isSignal": true; }; "stackButtons": { "alias": "stackButtons"; "required": false; "isSignal": true; }; "singleItemPerPage": { "alias": "singleItemPerPage"; "required": false; "isSignal": true; }; "showSelectors": { "alias": "showSelectors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "timer": { "alias": "timer"; "required": false; "isSignal": true; }; }, { "onNext": "onNext"; "onPrevious": "onPrevious"; "onChange": "onChange"; }, never, ["*"], true, never>;
+}
+
+declare class ButtonComponent {
+    /**
+     * The color of the button.
+     */
+    color: _angular_core.InputSignal<"primary" | "secondary" | "tertiary">;
+    /**
+     * Whether the button is disabled.
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * The text to display on the button.
+     */
+    text: _angular_core.InputSignal<string | null>;
+    alt: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The icon to display on the button.
+     */
+    icon: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The direction of the button.
+     */
+    direction: _angular_core.InputSignal<"left" | "right">;
+    /**
+     * Whether the button is rounded.
+     */
+    rounded: _angular_core.InputSignal<boolean>;
+    /**
+     * The size of the icon.
+     */
+    size: _angular_core.InputSignal<"small" | "medium" | "large">;
+    routerLink: _angular_core.InputSignal<string | any[] | UrlTree | null>;
+    routerLinkActive: _angular_core.InputSignal<string | string[]>;
+    getWidth(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "chr-button", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "routerLinkActive": { "alias": "routerLinkActive"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TabToInputHandlerDirective {
+    private el;
+    handleTab(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabToInputHandlerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabToInputHandlerDirective, "[tab-input-only]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TabToEnterHandlerDirective {
+    private el;
+    handleTab(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabToEnterHandlerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabToEnterHandlerDirective, "[tab-enter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AutofocusDirective {
+    private host;
+    readonly chrAutofocus: _angular_core.InputSignal<boolean | "" | null | undefined>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutofocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AutofocusDirective, "[chrAutofocus]", never, { "chrAutofocus": { "alias": "chrAutofocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const inOutAnimation: (duration?: number) => _angular_animations.AnimationTriggerMetadata;
+
+declare const rotationAnimation: (initialAngle?: number, endAngle?: number, duration?: number) => _angular_animations.AnimationTriggerMetadata;
+
+declare class DialogService {
+    private dialog;
+    openDelete: (callback?: Function, ...elements: Parameters<any>) => void;
+    openDefault: (config?: IDefaultDialogConfig) => void;
+    open: (component: any, options?: MatDialogConfig<any>) => MatDialogRef<any, any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
+}
+
+interface ModalOptions {
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    width?: number;
+    height?: number;
+    data?: any;
+}
+declare const CHR_MODAL_DATA: InjectionToken<any>;
+declare const CHR_MODAL_REF: InjectionToken<ModalRef<any>>;
+interface ModalData {
+    [key: string]: any;
+}
+interface ModalRef<T = any> {
+    componentInstance: T;
+    close: (result?: any) => void;
+    afterClosed: () => Observable<any>;
+}
+
+declare class ModalService {
+    private dialog;
+    private appRef;
+    private environmentInjector;
+    private activeModals;
+    open<T>(component: Type<T>, options?: ModalOptions): ModalRef<ChrModalComponent>;
+    closeAll(): void;
+    private closeModal;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModalService>;
+}
+
+declare class DataService {
+    private platformId;
+    private data;
+    private persistData;
+    private syncData;
+    constructor();
+    set: (key: string, value: any, persist?: boolean) => void;
+    get: (key: string) => Observable<any>;
+    getSync: (key: string) => any;
+    clear: (key: string) => void;
+    remove: (key: string) => boolean;
+    private persist;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataService>;
+}
+
+declare class CookiesService {
+    constructor();
+    /**
+     * delete cookie
+     * @param name
+     */
+    deleteCookie(name: string): void;
+    /**
+     * get cookie
+     * @param {string} name
+     * @returns {string}
+     */
+    getCookie(name: string): string;
+    /**
+     * set cookie
+     * @param {string} name
+     * @param {string} value
+     * @param {number} expireDays
+     * @param {string} path
+     */
+    setCookie(name: string, value: string, expireDays: number, path?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CookiesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CookiesService>;
+}
+
+declare class FileService {
+    constructor();
+    fileToBase64: (file: File) => Observable<IFile>;
+    toBase64: (file: IFile) => Observable<IFile>;
+    toBase64WithProgress: (file: IFile) => Observable<{
+        progress: number;
+        file?: IFile;
+    }>;
+    batchToBase64: (files: IFile[]) => Observable<IFile[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FileService>;
+}
+
+declare const SpinnerInterceptor: HttpInterceptorFn;
+
+declare const XsrfInterceptor: HttpInterceptorFn;
+declare const WaitAndStoreXsrfToken: (headername: string, dataService: DataService) => (source: Observable<HttpEvent<any>>) => Observable<HttpEvent<any>>;
+
+interface IXsrfProviderParams {
+    xsrfHeader: string;
+    xsrfCookie?: string;
+    hubUrl?: string;
+    interceptors?: HttpInterceptorFn[];
+    features?: HttpFeature<any>[];
+}
+declare const provideXsrfHttpClient: (params: IXsrfProviderParams) => any[];
+declare const XSRFHEADERNAME: InjectionToken<string>;
+declare const XSRFCOOKIENAME: InjectionToken<string>;
+declare const HUBURL: InjectionToken<string>;
+
+export { Aligments, AutofocusDirective, BreadcrumbComponent, ButtonComponent, CHR_MODAL_DATA, CHR_MODAL_REF, CarouselComponent, ChrBaseInputComponent, ChrButtonComponent, ChrCheckboxComponent, ChrColorInputComponent, ChrDataTable, ChrDateInputComponent, ChrDatetimeInputComponent, ChrDefaultModalComponent, ChrDeleteModalComponent, ChrFileInputComponent, ChrFormComponent, ChrModalComponent, ChrNiceFileInputComponent, ChrPaginatorComponent, ChrSearchSelectComponent, ChrSearchbarComponent, ChrSeparatorComponent, ChrSpinnerComponent, ChrTableComponent, ChrTableHeaderCellComponent, ChrTagSelectComponent, ChrTextareaInputComponent, ChrToastComponent, ChrToggleInputComponent, Colors, CookiesService, DEFAULTLIVEUPDATEMESSAGE, DataService, DecimalValidatorDirective, DefaultLiveUpdateMessage, DialogService, FileService, HUBURL, InlineSvgComponent, LiveUpdateService, LiveUpdateStatus, LoaderService, MaxDateValidatorDirective, ModalService, SpinnerInterceptor, SyncValidatorToAsync, TabComponent, TabGroupComponent, TabToEnterHandlerDirective, TabToInputHandlerDirective, ToastService, TypeValidatorDirective, WaitAndStoreXsrfToken, XSRFCOOKIENAME, XSRFHEADERNAME, XsrfInterceptor, decimal, getAsyncValidators, getBackgroundColor, getBorderColor, getContrastBackgroundColor, getContrastBorderColor, getContrastTextColor, getSyncValidators, getTextColor, getValidators, inOutAnimation, maxDate, provideXsrfHttpClient, rotationAnimation, type };
+export type { Alignment, Breadcrumb, Color, IAction, IChip, IChips, IColumn, IComputedColumn, IComputedRow, IControlValidation, IDefaultDialogConfig, IFormSection, IInputSearchFilter, ILiveUpdateMessage, IXsrfProviderParams, ModalData, ModalOptions, ModalRef, TColumn, TColumnType, Toast };