import * as _angular_core from '@angular/core'; import { OnInit, ViewContainerRef, AfterViewInit, Type, ApplicationRef, EnvironmentInjector, ComponentRef, OnDestroy, ElementRef, AfterViewChecked, AfterContentChecked, AfterContentInit, QueryList, EventEmitter, OutputEmitterRef, InputSignal, TemplateRef, Injector, InjectionToken, Signal } from '@angular/core'; import { Router, UrlTree, CanDeactivateFn } from '@angular/router'; import * as rxjs from 'rxjs'; import { Observable, Subject, BehaviorSubject } from 'rxjs'; import * as _angular_forms from '@angular/forms'; import { AbstractControl, ValidationErrors, ValidatorFn, AsyncValidatorFn, FormControl, FormGroup, ControlValueAccessor, NgControl, Validator } from '@angular/forms'; import { MatAutocomplete } from '@angular/material/autocomplete'; import * as _angular_platform_browser from '@angular/platform-browser'; import { SafeHtml, DomSanitizer, EventManagerPlugin } from '@angular/platform-browser'; import { HttpClient, HttpContextToken, HttpEventType, HttpInterceptorFn, HttpEvent, HttpFeature } from '@angular/common/http'; import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling'; import { Overlay } from '@angular/cdk/overlay'; import * as chrv_components from 'chrv-components'; export * from 'ngx-pagination'; export * from 'chrv-pipes'; interface Breadcrumb { display: string; link?: string; callback?: Function; } declare class BreadcrumbComponent { router: Router; readonly crumbs: _angular_core.InputSignal; navigateTo: (uri: string, data?: any) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type Color = 'primary' | 'primary-contrast' | 'secondary' | 'secondary-contrast' | 'tertiary' | 'tertiary-contrast' | 'warn' | 'warn-contrast' | 'error' | 'error-contrast' | 'black' | 'white' | 'text' | 'neutral' | 'background' | 'none'; declare const ColorsVariables: { [key in Color]: string; }; declare const Colors: { [key in Color]: 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 function getVariableColor(color?: Color): string; declare function getVariableContrastColor(color?: Color): string; declare class ChrButtonLegacyComponent { readonly display: _angular_core.InputSignal; readonly icon: _angular_core.InputSignal; readonly click: _angular_core.InputSignal; readonly clickWhileDisabled: _angular_core.InputSignal; readonly color: _angular_core.InputSignal; readonly textColor: _angular_core.InputSignal; readonly flat: _angular_core.InputSignal; readonly predicate: _angular_core.InputSignal; readonly type: _angular_core.InputSignal<"none" | "small" | "responsive" | "table" | "full" | "fixed">; readonly href: _angular_core.InputSignal; readonly target: _angular_core.InputSignal<"_blank" | "_parent" | "_self" | "_top" | undefined>; readonly disabled: _angular_core.InputSignal; readonly tooltip: _angular_core.InputSignal; readonly tooltipPosition: _angular_core.InputSignal<"above" | "below" | "left" | "right" | 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrModalComponent implements OnInit { dynamicContent: ViewContainerRef; /** * Indique si le modal est ouvert ou fermé. * @default false */ isOpen: _angular_core.InputSignal; /** * Indique si le modal doit se fermer lorsque l'utilisateur clique sur le fond. * @default true */ closeOnBackdropClick: _angular_core.ModelSignal; /** * Indique si le modal doit se fermer lorsque l'utilisateur appuie sur la touche Échap. * @default true */ closeOnEscape: _angular_core.ModelSignal; /** * Shorthand for closeOnBackdropClick and closeOnEscape * @default undefined */ disableClose: _angular_core.InputSignal; /** * Événement émis lorsque le modal doit être fermé. * @default undefined */ close: _angular_core.OutputEmitterRef; /** * Largeur du modal en pourcentage de la largeur de la fenêtre. */ width: _angular_core.InputSignal; /** * Hauteur du modal en pourcentage de la hauteur de la fenêtre. */ height: _angular_core.InputSignal; /** * Fond par défaut du conteneur modal. Par défaut, 'none' pour permettre la personnalisation via CSS avec la classe '.modal-wrapper' ou '.modal-content'. * @default 'none' */ background: _angular_core.InputSignal; constructor(); getDynamicContentContainer(): ViewContainerRef; onBackdropClick(): void; onModalClick(event: Event): void; onEscapeKey(event: Event): void; ngOnInit(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "chr-modal", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; }, { "closeOnBackdropClick": "closeOnBackdropClickChange"; "closeOnEscape": "closeOnEscapeChange"; "close": "close"; }, never, never, true, never>; } interface IContextMenuItem { /** * Label for the menu item */ label: string; /** * Action to trigger when the menu item is clicked */ action: Function | ((...params: any[]) => void | any); /** * Optional Material Icon name to display */ icon?: string; /** * Optional color for the hover background */ color?: Color; } 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: ((entry: any, index?: number) => void | any) | Function; disabled?: boolean; disabledCallback?: ((entry: any) => boolean) | Function; color: Color; } declare class ChrTableComponent implements OnInit, AfterViewInit { private _date; private dataService; private changeDetector; readonly computedRows: _angular_core.InputSignal; readonly columns: _angular_core.InputSignal; private _data; get data(): any[] | null; set data(value: any[] | null); readonly actions: _angular_core.InputSignal; readonly isAsc: _angular_core.ModelSignal; readonly sortBy: _angular_core.ModelSignal; readonly pageSize: _angular_core.ModelSignal; readonly currentPage: _angular_core.ModelSignal; readonly selectable: _angular_core.InputSignal; readonly selection: _angular_core.ModelSignal; readonly id: _angular_core.InputSignal; readonly color: _angular_core.InputSignal; readonly textColor: _angular_core.InputSignal; private _page; readonly contextMenuItems: (entry: any) => IContextMenuItem[]; currentProperty: any | null; currentText: string | null; ngOnInit(): void; ngAfterViewInit(): 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface ModalOptions { /** * Indicates if the modal is open or closed. * @default true */ closeOnBackdropClick?: boolean; /** * Indicates if the modal should close when the user presses the Escape key. * @default true */ closeOnEscape?: boolean; /** * Shorthand for closeOnBackdropClick and closeOnEscape */ disableClose?: boolean; /** * Width in vw */ width?: number; /** * Height in vh */ height?: number; /** * Extra configuration to be passed to the modal component instance */ extraConfig?: { /** * Title of the modal */ title: string; /** * Text/HTML content of the modal */ text: string; /** * Label for the close button * @default 'Fermer' */ close: string; /** * Array of actions to be shown as buttons in the modal */ actions: IAction[]; } | any; /** * Default background of the modal container. Defaults to 'none' as to allow customisation through css with the class '.modal-content'. * @default 'none' */ background?: Color; /** * Data to be passed to the modal component */ data?: any; } interface ModalData { [key: string]: any; } interface IModalRef { open: () => void; configure(options: ModalOptions): void; close: (result?: any) => void; afterClosed: () => Observable; } /** * Classe ModalRef générique qui gère la logique de création, configuration et fermeture des modales. * Cette classe extrait la logique du ModalService pour permettre une meilleure séparation des responsabilités. * * Usage dans le ModalService refactorisé: * ```typescript * open(component: Type, options: ModalOptions = {}): ModalRef { * const modalRef = new ModalRef(component, options); * const modalComponentRef = modalRef.create(); * this.activeModals.add(modalRef); * return modalRef; * } * ``` */ declare class ModalRef implements IModalRef> { private _component; private options; private _afterClosed; private modalComponentRef; private contentComponentRef; private appRef; private environmentInjector; constructor(_component: Type, options: ModalOptions, appRef: ApplicationRef, injector: EnvironmentInjector); /** * Returns the component instance of the modal content. * Throws an error if the content component is not initialized. */ get componentInstance(): T; /** * Returns the modal instance. * Throws an error if the modal component is not initialized. */ get instance(): ChrModalComponent; setWidth(width: number): void; setHeight(height: number): void; protected set(property: string, value: any): void; /** * Creates and initializes the modal component and its content */ create(): ComponentRef>; /** * Opens the modal by setting isOpen to true */ open(): void; /** * Closes the modal and emits the result */ close(result?: any): void; /** * Returns an observable that emits when the modal is closed */ afterClosed(): Observable; /** * Configures the modal with the provided options. * This methods allow dynamic configuration of the modal after its creation. * It will however not properly update the data as it is injected at creation time. * @param options */ configure(options: ModalOptions): void; private _configureModal; private _setInputs; private _attachToDom; } declare class ChrDeleteModalComponent { dialogRef: ModalRef; valid: boolean; constructor(); ngOnInit(): void; cancel: () => void; close: () => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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[]; declare const BaseErrorDisplays: { min: string; max: string; required: string; email: string; minlength: string; maxlength: string; type: string; decimal: string; maxdate: string; maxfilesize: string; minfilesize: string; }; type InputType = 'text' | 'password' | 'email' | 'textArea' | 'number' | 'date' | 'datetime' | 'time' | 'time-seconds' | 'month' | 'week' | 'searchSelect' | 'tagSelect' | 'color' | 'toggle' | 'file' | 'range' | 'tel' | 'url' | '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; disabled?: boolean; accept?: string[]; debounceTime?: number; value?: any; data?: any[] | null; icon?: string; iconCallback?: (data: any) => any | null | void; iconCallbackDisabled?: boolean; iconTooltip?: string; fn?: (object: any) => string; filters?: ISearchFilter[]; validations?: IControlValidation[]; addCallback?: ((entry: any, subject: Subject) => any | null | void) | null; editCallback?: ((entry: any, subject: Subject) => 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; mask?: string; shownMaskExpression?: string; maskValidation?: boolean; maskPrefix?: string | null; maskSuffix?: string | null; maskDropSpecialCharacters?: boolean; } interface IFormSection { title?: string; controls: IControl[]; } declare class ChrFormComponent implements OnInit { private builder; private changeDetector; private element; readonly sections: _angular_core.InputSignal; readonly controls: _angular_core.InputSignal; readonly validators: _angular_core.InputSignal; readonly valid: _angular_core.InputSignal; readonly validChange: _angular_core.OutputEmitterRef; readonly model: _angular_core.InputSignal; readonly modelChange: _angular_core.OutputEmitterRef; readonly formDataChange: _angular_core.OutputEmitterRef; readonly disabled: _angular_core.InputSignal; readonly valuesChanges: _angular_core.OutputEmitterRef; readonly submit: _angular_core.InputSignal; readonly compact: _angular_core.InputSignal; readonly debounceTime: _angular_core.InputSignal; readonly formChange: _angular_core.OutputEmitterRef<{ [key: string]: any; }>; readonly valueChanges: _angular_core.OutputEmitterRef<{ [name: string]: any; }>; readonly tabDisplay: _angular_core.InputSignal; 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>; readonly formChanges: _angular_core.OutputEmitterRef | 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 | 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 | 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; /** * 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; /** * The id of the input. */ readonly id: _angular_core.InputSignal; /** * 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.ModelSignal; /** * The value of the input. */ readonly value: _angular_core.ModelSignal; /** * The subject that holds the current value of the input. */ readonly valueSubject: BehaviorSubject; readonly displayValue: _angular_core.ModelSignal; readonly displayValueSubject: BehaviorSubject; /** * Override of the default input event that use the input's debouncing feature */ readonly input: _angular_core.OutputEmitterRef; /** * The subject that holds the input event values */ readonly inputSubject: Subject; /** * Whether or not the input is required */ readonly required: _angular_core.WritableSignal; /** * Span that will be shown under the input */ readonly span: _angular_core.InputSignal; /** * Name of the material icon that will be displayed */ readonly icon: _angular_core.InputSignal; /** * The step attribute of the input element. Mostly used for number and time input types. */ readonly step: _angular_core.InputSignal; /** * The min attribute of the input element. Mostly used for number and time input types. */ readonly min: _angular_core.InputSignal; /** * The max attribute of the input element. Mostly used for number and time input types. */ readonly max: _angular_core.InputSignal; /** * 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; /** * Tooltip that will be displayed when hovering the input's icon */ readonly iconTooltip: _angular_core.InputSignal; /** * Tooltip that will be displayed on hover */ readonly tooltip: _angular_core.InputSignal; /** * Debounce time that will be used by the input before throwing the new value event */ readonly debounceTime: _angular_core.InputSignal; /** * 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; /** * The error messages to display for the input. * The key is the error name and the value the message to display */ readonly errors: _angular_core.InputSignal<{ [index: string]: string; } | null>; private readonly errorDisplays; /** * Event that will be triggered when the input is focused */ focus: _angular_core.OutputEmitterRef; /** * Indicates whether or not this input should try catching the focus on page load */ readonly autofocus: _angular_core.InputSignal; /** * Event that will be triggered when the input is blurred (a.k.a) when the user clicks outside of the input or presses tab to leave the input. */ blur: _angular_core.OutputEmitterRef; /** * 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; /** * The input element. * May be undefined if the template does not contain an input element with the 'input' reference. * May also be undefined depending the lifecycle of the component. * May not be what is expected (ex: for file inputs, the input element is not the one that is displayed but the one that is hidden). */ inputRef: _angular_core.Signal | undefined>; /** * Getter and setter that allow the control of the FormControl's state from the template */ disabled: _angular_core.ModelSignal; /** * The autocomplete attribute of the input element */ autoComplete: _angular_core.InputSignal; /** * 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; onChange: any; onTouch: any; /** * Whether or not the input is touched */ isTouched: _angular_core.WritableSignal; /** * The NgControl associated with this input */ protected control: _angular_core.WritableSignal; /** * The validity status of the related FormControl */ isValid: boolean | null; /** * Input mask to be applied * @see https://www.npmjs.com/package/ngx-mask * @see https://jsdaddy.github.io/ngx-mask/#7 */ mask: _angular_core.InputSignal; /** * Mask expression shown in the input during typing */ maskShownExpression: _angular_core.InputSignal; /** * Should the mask be validated */ maskValidation: _angular_core.InputSignal; /** * Mask template shown below the input (for information purposes) */ maskShownTemplate: _angular_core.InputSignal; /** * Prefix to be added to the input value */ maskPrefix: _angular_core.InputSignal; /** * Suffix to be added to the input value */ maskSuffix: _angular_core.InputSignal; /** * Whether or not special characters should be removed from the value before it's set to the model. * Default is true */ maskDropSpecialCharacters: _angular_core.InputSignal; /** * 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) => Observable; writeValue(obj: any): void; registerOnChange(fn: any): void; registerOnTouched(fn: any): void; setDisabledState?(isDisabled: boolean): void; /** * Forces the input element to take focus. */ forceFocus: () => void; /** * Forces the input element to lose focus. */ forceBlur: () => void; getRawValue: () => any; 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 configureInitialDisplayValue; private configureTouchBehavior; private configureValidityReplication; private configureFormControl; protected doCallback: () => void; protected onHtmlInput: (event: Event) => void; protected visualState: () => "error" | "empty" | "valid" | "default"; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrColorInputComponent extends ChrBaseInputComponent implements OnInit, AfterViewInit, OnDestroy { readonly type: _angular_core.InputSignal; constructor(); parseColor: (event: string) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrDateInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy { private datePipe; private locale; readonly type: _angular_core.InputSignal; constructor(); ngOnInit(): void; onInputChange: (value: any) => void; parseDate: (event: string) => Date | null; dateToString: (value: Date) => string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrDatetimeInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy { private datePipe; private locale; readonly type: _angular_core.InputSignal; constructor(); ngOnInit(): void; onInputChange: (value: any) => void; parseDate: (event: string) => Date | null; dateToString: (value: Date) => string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IFile { name?: string; file?: File | null; url?: string | null; data?: string | null; extension?: string | null; contentType?: string | null; } declare class ChrFile implements IFile { name?: string; file?: File | null; url?: string | null; data?: string | null; extension?: string | null; contentType?: string | null; constructor(file: IFile); getUrl: () => string; private parseNameAndExtensionFromFile; } 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; /** * Whether or not the input should allow multiple file selection */ readonly multiple: _angular_core.InputSignal; 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; fileErrors: { [index: number]: boolean; } | null; files: Observable<{ progress: number; file?: IFile; }>[]; readonly type: _angular_core.InputSignal; constructor(); 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrTextareaInputComponent extends ChrBaseInputComponent implements OnInit, AfterViewInit, OnDestroy, AfterViewChecked, AfterContentChecked { readonly type: _angular_core.InputSignal; constructor(); ngAfterViewInit(): void; ngAfterContentChecked(): void; ngAfterViewChecked(): void; resize: (textArea?: HTMLTextAreaElement) => void; preventSubmit: (event: Event) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrToggleInputComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy { readonly type: _angular_core.InputSignal; constructor(); toggle: (event: any) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IInputSearchFilter { display: string; callback?: Function; tooltip?: string; } declare class ChrSearchSelectComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, OnDestroy { predicate: boolean; filteredModelOptions?: Observable; readonly _inputText: _angular_core.WritableSignal; readonly values: BehaviorSubject; readonly placeholder: _angular_core.InputSignal; readonly data: _angular_core.InputSignal; readonly data$: BehaviorSubject; readonly display: _angular_core.InputSignal<((entry: any) => string) | undefined>; readonly filters: _angular_core.InputSignal; readonly type: _angular_core.InputSignal; /** * 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 | 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; protected filterIndex: _angular_core.WritableSignal; protected overrideShowResults: _angular_core.WritableSignal; 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; /** * 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 enableShowPanel: (input: any) => void; protected disableShowPanel: () => void; protected addFromText: (event: any) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrTagSelectComponent extends ChrBaseInputComponent implements ControlValueAccessor, OnInit, OnDestroy { predicate: boolean; readonly autocomplete: _angular_core.Signal; protected overrideShowResults: boolean; filteredModelOptions?: Observable; protected textInputValue: _angular_core.WritableSignal; private values; readonly placeholder: _angular_core.InputSignal; readonly data: _angular_core.InputSignal; readonly data$: BehaviorSubject; readonly display: _angular_core.InputSignal<((entry: any) => string) | undefined>; readonly filters: _angular_core.InputSignal; readonly type: _angular_core.InputSignal; /** * 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 | 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 | 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; constructor(); protected filterIndex: _angular_core.WritableSignal; ngOnInit(): 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 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"; protected contextMenuItems: (entry: any) => IContextMenuItem[]; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; /** * Whether or not the table will show a column with a checkbox to select entries. Default is false */ readonly selectable: _angular_core.InputSignal; /** * The selected entries */ readonly selection: _angular_core.ModelSignal; /** * The table's action column definition */ readonly actions: _angular_core.InputSignal; readonly contextMenuItems: (entry: any) => IContextMenuItem[]; /** * Wheter or not the current sort is ascendant. Default is true */ readonly isAsc: _angular_core.ModelSignal; /** * The property by which the data will be sorted */ readonly sortBy: _angular_core.ModelSignal; /** * The page size for the table. Default is 20 */ readonly pageSize: _angular_core.ModelSignal; /** * The current page of the table. Default is 1 */ readonly currentPage: _angular_core.ModelSignal; /** * The ID of the table. It's used to persist page size and currentpage when the user change pages */ readonly id: _angular_core.InputSignal; /** * The color to use for the table's header */ readonly color: _angular_core.InputSignal; readonly primaryColor: _angular_core.Signal; readonly textColor: _angular_core.Signal; /** * The table's columns definitions */ readonly columns: _angular_core.InputSignal; ngOnInit(): 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; getVariableColor: (color: Color) => string; getVariableContrastColor: (color: Color) => string; protected sort: (properties?: string) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrNiceFileInputComponent extends ChrFileInputComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrSearchbarComponent { readonly model: _angular_core.InputSignal; readonly modelChange: _angular_core.OutputEmitterRef; readonly placeholder: _angular_core.InputSignal; readonly label: _angular_core.InputSignal; searchBy: FormControl; constructor(); emit(event: any): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrPaginatorComponent implements OnInit, AfterContentChecked { private service; private dataService; private pageInput; private pageSizeInput; page: _angular_core.InputSignal; pageChange: _angular_core.OutputEmitterRef; pageSize: _angular_core.InputSignal; pageSizeChange: _angular_core.OutputEmitterRef; private instance; protected dataSize: _angular_core.Signal; isLastPage: _angular_core.Signal; lastPage: _angular_core.Signal; protected contextMenuItems: _angular_core.Signal; protected currentlyShownSize: _angular_core.Signal; readonly id: _angular_core.InputSignal; readonly allowSizeChange: _angular_core.InputSignal; readonly allowPageEdit: _angular_core.InputSignal; isPageEditing: _angular_core.ModelSignal; constructor(); ngAfterContentChecked(): void; ngOnInit(): void; previous: () => void; next: () => void; setPage: (page: number) => void; setPageEventHandler: (event: any) => void; isFirstPage: _angular_core.Signal; setPageSize: (pageSize: number) => void; setPageSizeEventHandler: (event: any) => void; focusInput: () => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * This should only be used as a directive */ declare class ChrTableHeaderCellComponent { private changeDetector; readonly display: _angular_core.InputSignal; readonly column: _angular_core.InputSignal; readonly alignment: _angular_core.InputSignal; readonly isAsc: _angular_core.InputSignal; readonly isAscChange: _angular_core.OutputEmitterRef; readonly sortBy: _angular_core.InputSignal; readonly sortByChange: _angular_core.OutputEmitterRef; orderBy: (column?: string[]) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrCheckboxComponent { checked: boolean; readonly type: _angular_core.InputSignal<"success" | "info">; readonly disabled: _angular_core.InputSignal; readonly change: _angular_core.OutputEmitterRef<{ checked: boolean; }>; check(end: boolean): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrSeparatorComponent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; getStackSize: () => number; incrementStackSize: () => number; decrementStackSize: () => number; setStackSize: (value: number) => number; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class LiveUpdateService { private dataService; private _hubUrl; private _connection; private _xsrf; private _xsrfHeader; private _message; private _update; constructor(); initConnection: () => Observable; onUpdate(): Observable; closeConnection(): Observable; getMessage(): Observable; getHubUrl: () => string | null; private pushMessage; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface Toast { type: 'error' | 'success' | 'warning'; message: string; duration?: number; } declare class LegacyToastService { private toastQueue; private currentToastSubject; currentToast$: Observable; private toastCloseSubject; private default_duration; constructor(); current: () => Observable; 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class ChrToastComponent { toastService: LegacyToastService; readonly topmargin: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IStaticValueAction extends Partial { display: string; color: Color; value?: any; } declare class ChrDefaultModalComponent { private dialogRef; private config; private sanitizer; valid: boolean; readonly title: _angular_core.ModelSignal; readonly text: _angular_core.ModelSignal; readonly actions: _angular_core.ModelSignal; readonly close: _angular_core.ModelSignal; protected html: _angular_core.Signal; constructor(); ngOnInit(): void; closeModal: (action: IStaticValueAction) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class InlineSvgComponent implements OnInit { private http; private sanitizer; private el; src: _angular_core.InputSignal; class: _angular_core.InputSignal; svgContent: _angular_core.WritableSignal; height: _angular_core.InputSignalWithTransform; width: _angular_core.InputSignalWithTransform; constructor(http: HttpClient, sanitizer: DomSanitizer, el: ElementRef); ngOnInit(): void; transformWidth(value: number | string): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class TabComponent { label: _angular_core.InputSignal; disabled: _angular_core.InputSignal; active: _angular_core.WritableSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class TabGroupComponent implements AfterContentInit { tabs: QueryList; protected selectedIndex: _angular_core.WritableSignal; color: _angular_core.InputSignal; fade: _angular_core.InputSignal; ngAfterContentInit(): void; selectTab: (index: number) => void; getVariableColor(color: Color): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CarouselComponent implements AfterContentInit, AfterViewInit { private platformId; containerRef: ElementRef; onResize(): void; protected initialized: BehaviorSubject; protected resizeEvent: BehaviorSubject; protected resize: Observable; protected items: _angular_core.WritableSignal; protected pages: _angular_core.WritableSignal; /** * Whether the selectors should be stacked on top of the carousel body. * Defaults to true. */ stackSelectors: _angular_core.InputSignal; /** * Whether the buttons should be stacked on top of the carousel body. * Defaults to true. */ stackButtons: _angular_core.InputSignal; /** * 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; currentIndex: _angular_core.WritableSignal; /** * Whether to show the selectors. * Defaults to 'Roboto, sans-serif'. */ showSelectors: _angular_core.InputSignal; /** * Whether to show the next and previous buttons. * Defaults to true. */ showButtons: _angular_core.InputSignal; /** * An output event that emits when the user clicks the next button. */ onNext: _angular_core.OutputEmitterRef; /** * An output event that emits when the user clicks the previous button. */ onPrevious: _angular_core.OutputEmitterRef; /** * An output event that emits when the user selects a slide with the selector. */ onChange: _angular_core.OutputEmitterRef; /** * An observable that emits a value every `timer` seconds. * This is used to automatically advance the carousel. */ interval: Observable | 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; 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ButtonComponent { /** * The color of the button. */ color: _angular_core.InputSignal<"primary" | "secondary" | "tertiary">; /** * Whether the button is disabled. */ disabled: _angular_core.InputSignal; /** * The text to display on the button. */ text: _angular_core.InputSignal; alt: _angular_core.InputSignal; /** * The icon to display on the button. */ icon: _angular_core.InputSignal; /** * The direction of the button. */ direction: _angular_core.InputSignal<"left" | "right">; /** * Whether the button is rounded. */ rounded: _angular_core.InputSignal; /** * The size of the icon. */ size: _angular_core.InputSignal<"large" | "medium" | "small">; routerLink: _angular_core.InputSignal; routerLinkActive: _angular_core.InputSignal; getWidth(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type ButtonColors = 'primary' | 'secondary' | 'tertiary' | 'error' | 'warning' | 'success' | 'none'; declare class ChrButtonComponent implements OnInit { private elementRef; /** * Button's text */ display: _angular_core.InputSignal; variant: _angular_core.InputSignal<"filled" | "outlined" | "ghost">; padding: _angular_core.InputSignal<"large" | "medium" | "none">; /** * Name of the Google Material Symbols icon */ icon: _angular_core.InputSignal; iconSize: _angular_core.InputSignal<"large" | "medium" | "small" | "inherit">; /** * Button's color. It will affect both the text and the icon */ color: _angular_core.InputSignal; /** * HTML Button type */ type: _angular_core.InputSignal<"submit" | "button">; /** * Whether or not the button is disabled */ disabled: _angular_core.InputSignal; /** * Fixed width in REM */ fixed: _angular_core.InputSignal; /** * The input may be either a function that returns a value or an observable, or a value that will be wrapped in a click event. * If the value is an observable the button will enter a loading state during the observable's execution. Otherwise, the function will be executed and it's return value directly returned. * If the value is not a function, the value will be directly returned. * @param The function the value to be handled on click */ action: _angular_core.InputSignal; /** * The event that will be thrown when the button is clicked */ onAction: _angular_core.OutputEmitterRef<{ event: MouseEvent; value: any; }>; loading: _angular_core.ModelSignal; ngOnInit(): void; handleClick: (event: MouseEvent) => { event: MouseEvent; value: any; }; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrContextMenuComponent { items: _angular_core.InputSignal; click: _angular_core.OutputEmitterRef; constructor(); trigger: (item: IContextMenuItem) => void; getVariableColor(color: Color): string; getVariableContrastColor(color: Color): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class ChrDropdownComponent { isOpen: _angular_core.ModelSignal; id: _angular_core.InputSignal; title: _angular_core.InputSignal; private children; hasContent: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class DropdownTitle { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class DropdownContent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IMinimumColumnMetadata { tableSchema: string; tableName: string; columnName: string; columnDefault?: string | null; ordinalPosition: number; dataType: string | null; length: number; scale?: number | null; isNullable: boolean; isIdentity: boolean; isGenerated: boolean; isUpdatable: boolean; get tooltip(): string; } interface IDB2ColumnMetadata extends IMinimumColumnMetadata { tableCatalog: string; columnHeading?: string | null; columnText?: string | null; longComment?: string | null; maxLength?: number | null; minLength?: number | null; characterMaximumLength?: number | null; characterOctetLength?: number | null; characterMinLength?: number | null; numericPrecision?: number | null; numericPrecisionRadix?: number | null; numericScale?: number | null; dateTimePrecision?: number | null; identityGeneration?: string | null; identityStart?: string | null; identityIncrement?: string | null; identityMaximum?: string | null; identityMinimum?: string | null; identityCycle?: string | null; } declare class ColumnMetadata implements IDB2ColumnMetadata { tableCatalog: string; tableSchema: string; tableName: string; columnName: string; columnHeading?: string | null; columnText?: string | null; longComment?: string | null; ordinalPosition: number; columnDefault?: string | null; isNullable: boolean; dataType: string | null; maxLength?: number | null; minLength?: number | null; length: number; scale?: number | null; characterMaximumLength?: number | null; characterOctetLength?: number | null; characterMinLength?: number | null; numericPrecision?: number | null; numericPrecisionRadix?: number | null; numericScale?: number | null; dateTimePrecision?: number | null; isIdentity: boolean; identityGeneration?: string | null; identityStart?: string | null; identityIncrement?: string | null; identityMaximum?: string | null; identityMinimum?: string | null; identityCycle?: string | null; isGenerated: boolean; isUpdatable: boolean; constructor(data?: Partial); get fullTableName(): string; get tooltip(): string; } interface ITableConstraintReference extends IMinimumTableConstraintReference { constraintSchema: string; systemConstraintSchema: string; constraintName: string; uniqueConstraintSchema: string; systemUniqueConstraintSchema: string; uniqueConstraintName: string; columnCount: number; thisKey: ITableConstraintColumn; otherKey: ITableConstraintColumn; } declare class TableConstraintReference implements ITableConstraintReference { constraintSchema: string; systemConstraintSchema: string; constraintName: string; uniqueConstraintSchema: string; systemUniqueConstraintSchema: string; uniqueConstraintName: string; columnCount: number; thisKey: TableConstraintColumn; otherKey: TableConstraintColumn; constructor(data?: Partial); } interface IMinimumTableConstraintColumn { constraintName: string; tableName: string; tableSchema?: string; columnName: string; reference?: IMinimumTableConstraintReference | null; } interface IMinimumTableConstraintReference { constraintSchema: string; constraintName: string; columnCount: number; thisKey: IMinimumTableConstraintColumn; otherKey: IMinimumTableConstraintColumn; } interface ITableConstraintColumn extends IMinimumTableConstraintColumn { systemConstraintSchema: string; constraintSchema: string; systemTableName: string; tableSchema: string; systemTableSchema: string; systemColumnName: string; reference: ITableConstraintReference | null; } declare class TableConstraintColumn implements ITableConstraintColumn { constraintSchema: string; systemConstraintSchema: string; constraintName: string; tableName: string; systemTableName: string; tableSchema: string; systemTableSchema: string; columnName: string; systemColumnName: string; reference: TableConstraintReference | null; constructor(data?: Partial); } interface IMinimumTableConstraint { constraintSchema: string; constraintName: string; constraintType: string | 'PRIMARY KEY' | 'FOREIGN KEY' | 'UNIQUE' | 'CHECK'; tableName: string; columns: IMinimumTableConstraintColumn[]; } interface ITableConstraint extends IMinimumTableConstraint { constraintCatalog: string; tableCatalog: string; tableSchema: string; columns: ITableConstraintColumn[]; } declare class TableConstraint implements ITableConstraint { constraintCatalog: string; constraintSchema: string; constraintName: string; constraintType: string | 'PRIMARY KEY' | 'FOREIGN KEY' | 'UNIQUE' | 'CHECK'; tableCatalog: string; tableName: string; tableSchema: string; columns: TableConstraintColumn[]; constructor(data?: Partial); fullTableName(): string; fullConstraintName(): string; isPrimaryKey(): boolean; isForeignKey(): boolean; isUnique(): boolean; isCheck(): boolean; } interface IAnonymousTable { catalog: string; schema: string; name: string; description?: string; isReadOnly?: boolean; rowNumberIdentity: string; columnMetadatas: ColumnMetadata[]; tableConstraints: TableConstraint[]; hasPrimaryKey: boolean; rows: any[]; count: number; total: number; } interface IDataTable { name: string; schema: string; description?: string; rowNumberIdentity: string; rows: any[]; count: number; addRow(row: any): any; updateRow(row: any): boolean; removeRow(row: any): boolean; getRowIdentifier(row: any): string; getRowNumber(row: any): number; compareRows(row1: any, row2: any): boolean; primaryKeyColumns(): IMinimumColumnMetadata[]; getColumnByName(columnName: string): IMinimumColumnMetadata | undefined; getConstraintsByType(type: string): IMinimumTableConstraint[]; } declare abstract class BaseTable implements IDataTable { abstract name: string; abstract schema: string; abstract description?: string; abstract columnMetadatas: IMinimumColumnMetadata[]; abstract tableConstraints: IMinimumTableConstraint[]; abstract isReadOnly?: boolean; abstract hasPrimaryKey: boolean; abstract rows: any[]; abstract count: number; abstract rowNumberIdentity: string; abstract getRowIdentifier(row: any): string; abstract getRowNumber(row: any): number; abstract primaryKeyColumns(): IMinimumColumnMetadata[]; addRow(row: any): any; updateRow(row: any): boolean; removeRow(row: any): boolean; compareRows(row1: any, row2: any): boolean; getColumnByName(columnName: string): IMinimumColumnMetadata | IDB2ColumnMetadata | any | undefined; getConstraintsByType(type: string): IMinimumTableConstraint[]; } declare class AnonymousTable extends BaseTable implements IAnonymousTable, IDataTable { catalog: string; schema: string; name: string; description?: string; isReadOnly?: boolean; rowNumberIdentity: string; columnMetadatas: ColumnMetadata[]; tableConstraints: TableConstraint[]; hasPrimaryKey: boolean; rows: any[]; count: number; total: number; constructor(data: IAnonymousTable); fullName(): string; primaryKeyColumns(): ColumnMetadata[]; getRowIdentifier(row: any): string; getRowNumber(row: any): any; compareRows(row1: any, row2: any): boolean; addRow(row: any): any; generateTempRowIdentifier(): any; } declare enum DGFilterMode { EQUALS = 0, NOT_EQUALS = 1, CONTAINS = 2, LOWER_OR_EQUAL = 3, GREATER_OR_EQUAL = 4, STARTS_WITH = 5, ENDS_WITH = 6 } interface IFormatter { canFormat(value: any, metadata?: IMinimumColumnMetadata | null): boolean; format(value: any, metadatas?: IMinimumColumnMetadata, ...args: any[]): string | null; canEdit?(value: any, columnMetadata: IMinimumColumnMetadata): boolean; getEditInputType?(metadata: IMinimumColumnMetadata): string; parseValue?(inputValue: string): any; validateValue?(value: any, columnMetadata: IMinimumColumnMetadata): ValidationResult; } interface ValidationResult { isValid: boolean; errorMessage?: string; } declare class DataFormatterService { private formatters; constructor(); setFormatters(formatters: IFormatter[]): void; registerFormatter(formatter: IFormatter): void; getFormatter: (value: any, columnMetadata?: IMinimumColumnMetadata | null) => IFormatter | null; validateRow(row: any, columnMetadatas: IMinimumColumnMetadata[]): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class ModalService { private activeModals; private appRef; private environmentInjector; open(component: Type, options?: ModalOptions): IModalRef; close(modalRefType: Type): void; closeAll(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class ColumnFilter { readonly formatterService: DataFormatterService; readonly modalService: ModalService; readonly FilterMode: typeof DGFilterMode; isOpen: _angular_core.ModelSignal; by: _angular_core.InputSignal; suggestions: _angular_core.InputSignal; mode: _angular_core.ModelSignal; formatter: _angular_core.WritableSignal; private inputRef; input: _angular_core.Signal; columnMetadata: _angular_core.InputSignal; value: _angular_core.ModelSignal; error: _angular_core.WritableSignal; filterChange: _angular_core.OutputEmitterRef<{ column: string; mode: DGFilterMode; value: string; }>; constructor(); toggle: () => void; apply: () => void; onInputChange: (inputValue: string) => void; getModeLabel: (mode: DGFilterMode) => string; filterModes: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare enum DGGroupAggregationEnum { COUNT = 0, SUM = 1, AVERAGE = 2, MIN = 3, MAX = 4 } declare class ColumnGroup { readonly formatterService: DataFormatterService; readonly Aggregation: typeof DGGroupAggregationEnum; input: _angular_core.Signal | undefined>; isOpen: _angular_core.ModelSignal; by: _angular_core.InputSignal; mode: _angular_core.ModelSignal; aggregations: _angular_core.Signal; textValue: _angular_core.Signal; groupChange: _angular_core.OutputEmitterRef; constructor(); toggle: () => void; apply: () => void; onOptionSelected: (modeLabel: string) => void; getModeLabel: (mode: DGGroupAggregationEnum) => string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IDGAddedEntry { index: number; row: any; } interface IDGChangedEntry { index: number; original: any; current: any; } interface IDGDeletedEntry { index: number; row: any; } interface IDGSort { column: string; isAsc: boolean; } interface IDGFilter { column: string; mode: DGFilterMode | null; value: string; } interface IDGGroup { column: string; included: string[]; mode: DGGroupAggregationEnum; } interface IDGRow { id: string; data: any; flag: 'added' | 'modified' | 'deleted' | 'unchanged'; valid: boolean; } interface IPartialAction extends Omit { display: string; color?: Color; icon?: string; } interface IDisplayableColumn extends IMinimumColumnMetadata { displayName: string; } type IDGTrackByMode = 'primaryKey' | 'index'; declare class DataGrid implements OnInit, OnDestroy { readonly formatterService: DataFormatterService; id: _angular_core.WritableSignal<`${string}-${string}-${string}-${string}-${string}`>; title: _angular_core.InputSignal; table: _angular_core.ModelSignal; viewport: _angular_core.Signal; headerScroll: _angular_core.Signal | undefined>; currentPage: _angular_core.InputSignal; pageSize: _angular_core.InputSignal; pageChange: _angular_core.OutputEmitterRef; pageSizeChange: _angular_core.OutputEmitterRef; selectedColumn: _angular_core.WritableSignal; sort: _angular_core.ModelSignal; filter: _angular_core.ModelSignal<{ [key: string]: IDGFilter; }>; groupBy: _angular_core.ModelSignal; cellChange: _angular_core.OutputEmitterRef<{ index: number; row: any; column: IDisplayableColumn | IMinimumColumnMetadata | IDB2ColumnMetadata | any; value: any; }>; rowClick: _angular_core.OutputEmitterRef<{ rowIndex: number; row: any; event: Event; }>; enableVirtualization: _angular_core.InputSignal; allowFiltering: _angular_core.InputSignal; allowGrouping: _angular_core.InputSignal; allowInsert: _angular_core.InputSignal; allowUpdate: _angular_core.InputSignal; allowDelete: _angular_core.InputSignal; allowSync: _angular_core.InputSignal; allowRefresh: _angular_core.InputSignal; allowNavigation: _angular_core.InputSignal; allowExport: _angular_core.InputSignal; allowManageTrackingPersistence: _angular_core.InputSignal; allowManageDistincValueFetching: _angular_core.InputSignal; maxHeight: _angular_core.InputSignal; onExport: _angular_core.OutputEmitterRef; onSync: _angular_core.OutputEmitterRef; onRefresh: _angular_core.OutputEmitterRef; onAddRow: _angular_core.OutputEmitterRef; onDeleteRow: _angular_core.OutputEmitterRef<{ index: number; row: any; }>; /** * Only supported for DB2 tables. For other types, use the onNavigate event. */ onForeignTableNavigate: _angular_core.OutputEmitterRef<{ targetTable: string; targetSchema: string; }>; onNavigate: _angular_core.OutputEmitterRef<{ targetColumnMetadata: IMinimumColumnMetadata; }>; onFilterValueChange: _angular_core.OutputEmitterRef<{ column: string; value: string; }>; allowFetchDistinctValues: _angular_core.ModelSignal; crossRequestTrackingPersistence: _angular_core.ModelSignal; modifiedCells: _angular_core.ModelSignal<{ rowIndex: number; columnName: string; originalValue: any; currentValue: any; }[]>; modifiedRows: _angular_core.ModelSignal; addedRows: _angular_core.ModelSignal; deletedRows: _angular_core.ModelSignal; distinctValues: _angular_core.InputSignal<{ [key: string]: any[]; }>; actions: _angular_core.InputSignal; columnSuggestions: _angular_core.Signal<{ [key: string]: any[]; }>; trackByMode: _angular_core.ModelSignal; hasChanges: _angular_core.Signal; groupByMap: _angular_core.Signal<{ [key: string]: boolean; }>; columns: _angular_core.Signal; rows: _angular_core.Signal; totalItems: _angular_core.Signal; currentItems: _angular_core.Signal; constructor(); ngOnInit(): void; ngOnDestroy(): void; getColumnTooltip(column: IMinimumColumnMetadata): string; toggleSort(columnName: string): void; setSort(columnName: string, isAsc: boolean): void; onFilterBy(columnName: string, filter: { column: string; mode: DGFilterMode; value: string; }): void; onFilterValue: (columnName: string, value: any) => void; onGroupBy(group: IDGGroup): void; onGroupByIncludedChange: (columnName: string, included: boolean) => void; onPageChange(page: number): void; onPageSizeChange(pageSize: number): void; refresh(): void; getCellValue(row: any, columnName: string): any; onCellChange: (index: number, row: IDGRow, column: IMinimumColumnMetadata, value: any) => void; isRowAdded(row: any, index: number): boolean; isRowChanged(row: any, index: number): boolean; isCellChanged(rowIndex: number, columnName: string): boolean; isRowDeleted(row: any, index: number): boolean; addRow: () => void; deleteRow(index: number, row: any): void; navigateToForeignTable(column: IMinimumColumnMetadata): void; resetChanges(): void; getChangeSummary(): { modified: any[]; added: any[]; deleted: any[]; hasChanges: boolean; }; getRowTrackBy: (row: any, index: number) => number; hasInvalidRows: () => boolean; validateRow: (row: any) => boolean; canEdit: (column: IMinimumColumnMetadata) => boolean; isPrimaryKeyColumn: (column: IMinimumColumnMetadata) => boolean; isUniqueKeyColumn: (column: IMinimumColumnMetadata) => boolean; isEditSafe: (column: IMinimumColumnMetadata) => boolean; isForeignKeyColumn: (column: IMinimumColumnMetadata) => boolean; toggleCrossRequestTrackingPersistence(): void; toggleAllowFetchDistinctValues(): void; onViewportScroll(event: Event): void; datagridContextMenuActions: (column: string, filterElement: ColumnFilter, groupElement: ColumnGroup) => IContextMenuItem[]; datarowContextMenuActions: (row: IDGRow, rowIndex: number) => IContextMenuItem[]; onAdd: () => void; log: (event: any) => void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class EditableCell implements OnInit, OnDestroy { readonly formatterService: DataFormatterService; allowUpdate: _angular_core.InputSignal; isTouched: _angular_core.WritableSignal; hasChanged: _angular_core.WritableSignal; formatter: _angular_core.WritableSignal; private inputRef; input: _angular_core.Signal; inputType: _angular_core.Signal; private spanRef; spanElement: _angular_core.Signal; value: _angular_core.InputSignal; valueChange: _angular_core.OutputEmitterRef; formattedValue: _angular_core.Signal