@sumaris-net/ngx-components 18.14.0 → 18.14.2

package/src/app/shared/file/url.utils.d.ts

@@ -0,0 +1,99 @@
+export declare abstract class UrlUtils {
+    /**
+     * Determines if a given URL is a relative URL.
+     *
+     * @param {string | null} href - The URL to check.
+     * @return {boolean} True if the URL is relative, false otherwise.
+     */
+    static isRelativeUrl(href: string | null): boolean;
+    /**
+     * Determines if a given URL is an internal URL.
+     *
+     * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.
+     * @return {boolean} Returns true if the URL is internal, otherwise false.
+     */
+    static isInternalUrl(href: string | null): boolean;
+    static isExternalUrl(href: string | null): boolean;
+    /**
+     * Removes the query string from the given URL, returning only the base URL.
+     *
+     * @param {string} url - The URL from which the query string will be stripped.
+     * @return {string} The URL without the query string.
+     */
+    static stripQuery(url: string): string;
+    /**
+     * Removes the fragment and query components from a given URL string.
+     *
+     * @param {string} url - The URL string to process.
+     * @return {string} The URL without its fragment and query components.
+     */
+    static stripFragmentAndQuery(url: string): string;
+    /**
+     * Extracts the fragment identifier from the given URL.
+     *
+     * @param {string} url - The URL from which to extract the fragment.
+     * @return {string} The fragment identifier of the URL, excluding the '#' symbol.
+     */
+    static getFragment(url: string): string;
+    static resolveRelativeUrl(baseUrl: string, relativePath: string, opts?: {
+        absoluteByDefault: boolean;
+    }): string;
+    /**
+     * Resolves a given URL by normalizing its parts, removing unnecessary path segments like "." and "..".
+     *
+     * @param {string} url - The URL to be resolved. Must be a non-empty string.
+     * @return {string} The resolved and cleaned URL string.
+     * @throws {Error} If the provided URL is missing or undefined.
+     */
+    static normalizeUrl(url: string): string;
+    /**
+     * This function completes a base URL with an object containing key-value pairs
+     * representing the query parameters to add. It properly encodes the
+     * parameters and ensures they are added with the appropriate separator ('?' or '&').
+     * Parameters with null or undefined values are automatically filtered out.
+     *
+     * @example
+     * // In a template
+     * <a [href]="'https://example.com' | appendQueryParams:{id: 123, name: 'test'}">Link</a>
+     * // Result: https://example.com?id=123&name=test
+     *
+     * @example
+     * // If the URL already contains parameters
+     * <a [href]="'https://example.com?page=1' | appendQueryParams:{sort: 'asc'}">Link</a>
+     * // Result: https://example.com?page=1&sort=asc
+     *
+     * @param url
+     * @param queryParams
+     */
+    static appendQueryParams(url: string | any[], queryParams: {
+        [key: string]: any;
+    }): string;
+    /**
+     * Extracts and returns the root URL from the given complete URL string.
+     *
+     * @param {string} url - The complete URL string from which the root URL will be extracted.
+     * @return {string} The root URL including the protocol and host (and port if present).
+     * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.
+     */
+    static getRootUrl(url: string): string;
+    /**
+     * Retrieves the parent URL or directory path from the provided URL.
+     * This method handles both relative and absolute URLs.
+     *
+     * @param {string} url - The URL from which to derive the parent path.
+     *                       Must be a valid URL or relative path.
+     * @return {string} The parent URL or directory path. Throws an error if the input is invalid.
+     */
+    static getParent(url: string): string;
+    /**
+     * Cleans the provided URL by encoding it safely and replacing specific patterns.
+     *
+     * @param {string} href - The URL string to be cleaned.
+     * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.
+     */
+    static cleanUrl(href: string): string;
+    static addTrailingSlash(url: string): string;
+    static addStartingSlash(url: string): string;
+    static removeStartingSlash(url: string): string;
+    static concat(basePath: string, relativePath: string): string;
+}

package/src/app/shared/focusable.d.ts

@@ -0,0 +1,4 @@
+export interface FocusableElement {
+    focus(): any;
+}
+export declare function isFocusableElement(object: any): object is FocusableElement;

package/src/app/shared/form/field.component.d.ts

@@ -0,0 +1,85 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, Injector, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, UntypedFormControl } from '@angular/forms';
+import { AppFloatLabelType, DisplayFn, FormFieldDefinition, FormFieldType } from './field.model';
+import { TranslateService } from '@ngx-translate/core';
+import { filterNumberInput, selectInputContentFromEvent } from '../inputs';
+import { Property } from '../types';
+import { ThemePalette } from '@angular/material/core';
+import { PredefinedColors } from '@ionic/core';
+import { MatAutocompleteField } from '../material/autocomplete/material.autocomplete';
+import { MatFormFieldAppearance, SubscriptSizing } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class AppFormField implements OnInit, ControlValueAccessor {
+    protected translate: TranslateService;
+    protected cd: ChangeDetectorRef;
+    protected injector: Injector;
+    private formGroupDir;
+    private _onChangeCallback;
+    private _onTouchedCallback;
+    private _definition;
+    protected _values: Property[];
+    protected type: FormFieldType;
+    protected numberInputStep: string;
+    set definition(value: FormFieldDefinition);
+    get definition(): FormFieldDefinition;
+    readonly: boolean;
+    disabled: boolean;
+    formControl: UntypedFormControl;
+    formControlName: string;
+    placeholder: string;
+    compact: boolean;
+    required: boolean;
+    hideRequiredMarker: boolean;
+    floatLabel: AppFloatLabelType;
+    label: string;
+    appearance: MatFormFieldAppearance;
+    subscriptSizing: SubscriptSizing;
+    tabindex: number;
+    autofocus: boolean;
+    clearable: boolean;
+    chipColor: ThemePalette | PredefinedColors;
+    classList: string;
+    debug: boolean;
+    panelClass: string;
+    panelWidth: string;
+    onKeyupEnter: EventEmitter<any>;
+    get value(): any;
+    matInput: ElementRef;
+    autocompleteField: MatAutocompleteField;
+    constructor(translate: TranslateService, cd: ChangeDetectorRef, injector: Injector, formGroupDir: FormGroupDirective);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    markAsTouched(): void;
+    filterAlphanumericalInput(event: KeyboardEvent): void;
+    focus(): void;
+    filterNumberInput: typeof filterNumberInput;
+    selectInputContentFromEvent: typeof selectInputContentFromEvent;
+    getDisplayValueFn(definition: FormFieldDefinition): DisplayFn;
+    getColorContrast(color: string): string | undefined;
+    /**
+     * Allow to reload values, if not detected
+     *
+     * @param value
+     */
+    reloadItems(value?: any): void;
+    protected computeNumberInputStep(definition: FormFieldDefinition): string;
+    protected checkAndResolveFormControl(): void;
+    protected _onDefinitionChanged(definition: FormFieldDefinition, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected updateTabIndex(timeout?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppFormField, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppFormField, "app-form-field", never, { "definition": { "alias": "definition"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "subscriptSizing": { "alias": "subscriptSizing"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "chipColor": { "alias": "chipColor"; "required": false; }; "classList": { "alias": "class"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; }, { "onKeyupEnter": "keyup.enter"; }, never, ["[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matPrefix]", "[matSuffix]", "[matSuffix]"], false, never>;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_compact: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_hideRequiredMarker: unknown;
+    static ngAcceptInputType_tabindex: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_debug: unknown;
+}

package/src/app/shared/form/field.model.d.ts

@@ -0,0 +1,82 @@
+import { ObjectMap, Property } from '../types';
+import { InjectionToken, Injector } from '@angular/core';
+import { MatAutocompleteFieldConfig } from '../material/autocomplete/material.autocomplete.config';
+import { UserProfileLabel } from '../../core/services/model/person.model';
+import { FloatLabelType } from '@angular/material/form-field';
+export declare type DisplayFn = (obj: any) => string;
+export declare type EqualsFn = (o1: any, o2: any) => boolean;
+export declare type CompareFn = (o1: any, o2: any) => number;
+export declare type FormFieldType = 'integer' | 'double' | 'boolean' | 'string' | 'enum' | 'enums' | 'color' | 'peer' | 'entity' | 'entities' | 'date' | 'dateTime';
+export declare type AppFloatLabelType = FloatLabelType | 'never';
+export declare interface FormFieldDefinition<K = string, T = FormFieldType, E = any> {
+    key: K;
+    type: T;
+    label: string;
+    minValue?: number;
+    maxValue?: number;
+    maximumNumberDecimals?: number;
+    defaultValue?: any;
+    isTransient?: boolean;
+    values?: (string | Property)[] | InjectionToken<(string | Property)[]>;
+    autocomplete?: MatAutocompleteFieldConfig<E>;
+    disabled?: boolean;
+    required?: boolean;
+    extra?: {
+        [key: string]: {
+            disabled?: boolean;
+            required: boolean;
+        };
+    };
+    minProfile?: UserProfileLabel;
+    /**
+     * Use for automatic serialization/deserialization to/from string (eg. using the autocomplete suggestFn).
+     * Default value: 'id'
+     */
+    serializeAttribute?: string;
+    /**
+     * Use to serialize an entity into string (see AppPropertiesUtils.***asObject())
+     * @param value
+     */
+    serialize?: (value: E) => string;
+    /**
+     * Use to deserialize a string into an entity (see AppPropertiesUtils.***fromObject())
+     * @param value
+     */
+    deserialize?: (value: string) => E | Promise<E>;
+}
+export declare type FormFieldDefinitionMap = ObjectMap<FormFieldDefinition>;
+export declare class FormFieldDefinitionUtils {
+    /**
+     * Prepares an array of form field definitions by using the specified injector to process each definition.
+     *
+     * @param {Injector} injector - The injector used to process each form field definition.
+     * @param {FormFieldDefinition[]} defs - An array of form field definitions to be prepared.
+     * @return {FormFieldDefinition[]} An array of prepared form field definitions.
+     */
+    static prepareDefinitions(injector: Injector, defs: FormFieldDefinition[]): FormFieldDefinition[];
+    /**
+     * Prepares the definition by processing its type and optionally setting the values property.
+     *
+     * @param {Injector} injector - The injector used to get the necessary services.
+     * @param {FormFieldDefinition} def - The form field definition to be prepared.
+     * @return {FormFieldDefinition} - The prepared form field definition with updated values if the type is 'enum' or 'enums'.
+     */
+    static prepareDefinition(injector: Injector, def: FormFieldDefinition): FormFieldDefinition;
+    /**
+     * Retrieves an array of Property objects from the provided enum values.
+     *
+     * @param {Injector} injector - The Angular injector to resolve the InjectionToken.
+     * @param {(string | Property)[] | InjectionToken<(string | Property)[]>} enumValues - The enum values, which can be an array of strings, array of Property objects, or an InjectionToken that resolves to such an array.
+     * @return {Property[]} An array of Property objects.
+     */
+    static getEnumValues(injector: Injector, enumValues: (string | Property)[] | InjectionToken<(string | Property)[]>): Property[];
+    static getDisplayValueFn(definition: FormFieldDefinition): DisplayFn;
+    private static asPropertyArray;
+}
+export declare abstract class FormFieldValuesHolder {
+    getAsBoolean(data: ObjectMap, definition: FormFieldDefinition): boolean;
+    getAsInt(data: any, definition: FormFieldDefinition): number;
+    getAsNumbers(data: any, definition: FormFieldDefinition): number[];
+    getAsStrings(data: any, definition: FormFieldDefinition): string[];
+    get<T = string>(data: any, definition: FormFieldDefinition): T;
+}

package/src/app/shared/form/loading-spinner.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class AppLoadingSpinner {
+    loading: boolean;
+    color: string | undefined;
+    name: 'bubbles' | 'circles' | 'circular' | 'crescent' | 'dots' | 'lines' | 'lines-small' | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppLoadingSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppLoadingSpinner, "app-loading-spinner", never, { "loading": { "alias": "loading"; "required": false; }; "color": { "alias": "color"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/src/app/shared/forms.d.ts

@@ -0,0 +1,162 @@
+import { AbstractControl, UntypedFormArray, UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { WaitForOptions } from './observables';
+import { Predicate } from '@angular/core';
+export interface FormErrors {
+    [key: string]: ValidationErrors;
+}
+/**
+ * Fill a form using a source entity
+ *
+ * @param target
+ * @param entity
+ * @param opts
+ */
+export declare function copyEntity2Form(entity: any, target: UntypedFormGroup, opts?: {
+    emitEvent?: boolean;
+    onlySelf?: boolean;
+}): void;
+export declare function getFormValueFromEntity(entity: any | undefined, form: UntypedFormGroup): {
+    [key: string]: any;
+};
+/**
+ * Transform an entity into a simple object, compatible with the given form
+ *
+ * @param source an entity (or subentity)
+ * @param control
+ * @param path
+ */
+export declare function adaptValueToControl(source: any | undefined, control: AbstractControl, path?: string): any;
+export declare function logFormErrors(control: AbstractControl, logPrefix?: string, path?: string): void;
+/**
+ * Retrieves all validation errors from a given form control, including its child controls if it is a form group or array.
+ *
+ * @param {AbstractControl} control - The form control to retrieve errors from. This can be a form group, a form array, or a simple form control.
+ * @param {Object} [opts] - Optional configurations for error retrieval.
+ * @param {string} [opts.controlName] - The name or path of the control being processed, used for structuring error keys in the result.
+ * @param {FormErrors} [opts.result] - The object to which errors will be added, allowing for aggregation and persistence between calls.
+ * @param {boolean} [opts.recursive=true] - Whether to recursively collect errors from child controls within a form group or array. Defaults to true.
+ * @return {FormErrors} The collected errors as a key-value object where keys represent control names or paths and values represent their respective errors. Returns `undefined` if the provided control is valid and has no errors.
+ */
+export declare function getFormErrors(control: AbstractControl, opts?: {
+    controlName?: string;
+    result?: FormErrors;
+    recursive?: boolean;
+}): FormErrors;
+/**
+ * Retrieves a control from the provided form/control structure using a dot-separated path.
+ *
+ * @param {AbstractControl} form - The root form group, form array, or control to start searching from.
+ * @param {string} path - The dot-separated path specifying the control. For example, 'groupName.controlName' or 'arrayName.0.controlName'.
+ * @param {boolean} [strict=true] - If true, throws an error if the full path cannot be resolved; if false, returns the last valid control encountered.
+ * @return {AbstractControl} - The control at the specified path or the closest valid control if strict mode is disabled.
+ * @throws {Error} - Throws an error if the path cannot be resolved and strict mode is enabled.
+ */
+export declare function getControlFromPath(form: AbstractControl, path: string, strict?: boolean): AbstractControl;
+export declare function disableControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableAndClearControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function enableControls(form: UntypedFormGroup, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function setControlsEnabled(form: UntypedFormGroup, enabled: boolean, paths: string[], opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+/**
+ * Sets form errors on an AbstractControl, including nested controls within form groups or arrays.
+ *
+ * @param {AbstractControl} control - The form control, form group, or form array to apply the errors to.
+ * @param {FormErrors} errors - An object representing the errors to be set on the control or its children.
+ * @return {void} Does not return a value.
+ */
+export declare function setFormErrors(control: AbstractControl, errors: FormErrors): void;
+export declare function enableControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function disableAndClearControl(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function setControlEnabled(control: AbstractControl, enabled: boolean, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    required?: boolean;
+}): void;
+export declare function addValueInArray(arrayControl: UntypedFormArray, createControl: (value?: any) => AbstractControl, equals: (v1: any, v2: any) => boolean, isEmpty: (value: any) => boolean, value: any, options?: {
+    emitEvent: boolean;
+    insertAt?: number;
+    allowManyNullValues?: boolean;
+    allowDuplicateValue?: boolean;
+}): boolean;
+/**
+ * Set an array using given default values. Each default value will be pass to the 'createControl()' function
+ *
+ * @param arrayControl
+ * @param createControl
+ * @param defaultValues
+ * @param options
+ */
+export declare function initArrayControlsFromValues(arrayControl: UntypedFormArray, createControl: (value?: any) => AbstractControl, defaultValues: any[], options?: {
+    emitEvent?: boolean;
+}): boolean;
+export declare function resizeArray(arrayControl: UntypedFormArray, createControl: () => AbstractControl, length: number, options?: {
+    emitEvent?: boolean;
+}): boolean;
+export declare function removeValueInArray(arrayControl: UntypedFormArray, isEmpty: (value: any) => boolean, index: number): boolean;
+export declare function clearValueInArray(arrayControl: UntypedFormArray, isEmpty: (value: any) => boolean, index: number): boolean;
+export declare function markAllAsTouched(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markFormGroupAsTouched(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markControlAsTouched(control: AbstractControl, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function updateValueAndValidity(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+}): void;
+export declare function markAsUntouched(form: UntypedFormGroup, opts?: {
+    onlySelf?: boolean;
+}): void;
+/**
+ * Wait end of async validation (not pending). This need to implement {pending: boolean}
+ * return false
+ */
+export declare function waitWhilePending<T extends {
+    pending: boolean;
+}>(form: T, opts?: WaitForOptions): Promise<void>;
+/**
+ * Wait form is idle (not loading). This need to implement {loading: boolean}
+ *
+ * @param form
+ * @param opts
+ */
+export declare function waitIdle<T extends {
+    loading: boolean;
+}>(form: T, opts?: WaitForOptions): Promise<void>;
+export declare function filterFormErrorsByPrefix(errors: FormErrors, ...prefixes: string[]): FormErrors;
+export declare function filterFormErrorsByPath(errors: FormErrors, filter: Predicate<string>): FormErrors;
+export declare function filterFormErrors(errors: FormErrors, filter: Predicate<[string, any]>): FormErrors;

package/src/app/shared/functions.d.ts

@@ -0,0 +1,206 @@
+import { KeysEnum, KeyValueType } from './types';
+import { RegExpUtils } from './regexps';
+export declare function isNil<T>(obj: T | null | undefined): boolean;
+export declare function isNilOrBlank<T>(obj: T | null | undefined): boolean;
+export declare function isNotNil<T>(obj: T | null | undefined): boolean;
+export declare function isNotNilOrBlank<T>(obj: T | null | undefined): boolean;
+export declare function isNotNilOrNaN<T>(obj: T | null | undefined): boolean;
+export declare function isNilOrNaN<T>(obj: T | null | undefined): boolean;
+export declare function isNotEmptyArray<T>(obj: T[] | null | undefined): boolean;
+export declare function firstArrayValue<T>(obj: T[] | null | undefined): T | undefined;
+export declare function lastArrayValue<T>(obj: T[] | null | undefined): T | undefined;
+export declare function isEmptyArray<T>(obj: T[] | null | undefined): boolean;
+export declare function arrayResize<T>(array: T[] | null | undefined, size: number, defaultValue?: T): T[];
+export declare function newArray<T>(size: number, defaultValue?: T): T[];
+export declare function isNotNilBoolean(obj: any | null | undefined): obj is boolean;
+export declare function isNotNilString(obj: any | null | undefined): obj is string;
+export declare function isNotNilObject(obj: any | null | undefined): obj is object;
+export declare function isBlankString(obj: any | null | undefined): obj is string;
+export declare function notNilOrDefault<T>(obj: T | null | undefined, defaultValue: T): T;
+export declare function arraySize<T>(obj: T[] | null | undefined): number;
+/**
+ * Remove duplicated value, in array. Will compute a unique key (from given properties, or given function).
+ * If propertiesOrKeyFn is nil or undefined, will use all object properties
+ *
+ * @param values
+ * @param propertiesOrKeyFn
+ */
+export declare function arrayDistinct<T = any>(values: T[], propertiesOrKeyFn?: string | string[] | ((obj: T) => string)): T[];
+export declare function nullIfUndefined<T>(obj: T | null | undefined): T | null;
+export declare function nullIfNilOrBlank<T>(obj: T | null | undefined): T | null;
+export declare function undefinedIfNull<T>(obj: T | null | undefined): T | undefined;
+export declare function trimEmptyToNull<T>(str: string | null | undefined): string | null;
+export declare function toBoolean(obj: boolean | null | undefined | string, defaultValue?: boolean): boolean;
+export declare function toNumber(obj: number | null | undefined | string, defaultValue?: number): number;
+export declare function toFloat(obj: string | null | undefined, defaultValue?: number): number | null;
+export declare function toInt(obj: string | null | undefined, defaultValue?: number): number | null;
+export declare function toNotNil<T = any>(obj: T, defaultValue?: T): any | null;
+export declare function removeDuplicatesFromArray<T>(obj: T[] | null | undefined, property?: string): T[] | null | undefined;
+export declare function startsWithUpperCase(input: string, search: string): boolean;
+/**
+ * @deprecated Use Regexps.matchUpperCase instead
+ */
+export declare const matchUpperCase: typeof RegExpUtils.matchUpperCase;
+/**
+ * Remove trailing slash if any. Examples :
+ * - '/test/' -> '/test'
+ * - '/' -> undefined
+ */
+export declare function noTrailingSlash(path: string): string;
+export declare function replaceAll(value: string, searchString: any, replacement: any): string | undefined;
+export declare function escapeRegExp(value: string): string;
+export declare function removeEnd(value: string, end: string): string;
+/**
+ * Replace case change by an underscore (.e.g 'myString' becomes 'my_string')
+ *
+ * @param value
+ */
+export declare function changeCaseToUnderscore(value: string): string;
+/**
+ * Replace underscore by a change case (.e.g 'MY_STRING' becomes 'MyString')
+ *
+ * @param value
+ */
+export declare function underscoreToChangeCase(value: string): string;
+export declare function removeDiacritics(text: string): string;
+export declare function suggestFromStringArray(values: string[], searchText: any, opts?: {
+    anySearch?: boolean;
+}): string[];
+export declare function joinPropertiesPath<T = any>(obj: T, properties: string[], separator?: string): string | undefined;
+export declare function joinProperties<T = any, K extends keyof T = any>(obj: T, keys: K[], separator?: string): string | undefined;
+export declare function propertyPathComparator<T = any>(path: string | string[]): (a: T, b: T) => number;
+export declare function propertyComparator<T = any, K extends keyof T = any>(key: K, defaultValue?: any): (a: T, b: T) => number;
+export declare function propertiesPathComparator<T = any>(keys: string[], defaultValues?: any[]): (a: T, b: T) => number;
+export declare function sort<T>(array: T[], attribute?: string, opts?: Intl.CollatorOptions): T[];
+export declare function isInt(value: string): boolean;
+export declare function isNumber(value: string): boolean;
+export declare function isNumberRange(value: string): boolean;
+export declare function getPropertyByPath(obj: any, path: string | Array<string | number>, defaultValue?: any): any;
+export declare function getProperty<T = any, K extends keyof T = any>(obj: T, key: K): T[K];
+export declare function getPropertyByPathAsString(obj: any, path: string | string[], defaultValue?: string): string | undefined;
+/**
+ * Update an object's property, using a path (like '<property_1>.<sub_property_1>')
+ * @param obj
+ * @param path
+ * @param value
+ * @return the given obj
+ */
+export declare function setPropertyByPath<T = any>(obj: T, path: string | string[], value: any): T;
+export declare function sleep(ms: number): Promise<void>;
+export declare function isPromise<T>(value: T | Promise<T>): value is Promise<T>;
+/**
+ * Rounds a numeric value to two decimal places.
+ *
+ * @param {number | undefined | null} value - The value to be rounded. Can be a number, undefined, or null.
+ * @param nbDecimal the number of decimal (default: 2)
+ * @return {number} The rounded value with two decimal places if the input value is a valid number; otherwise, returns the input value.
+ */
+export declare function round(value: number | undefined | null, nbDecimal?: number): number;
+export declare function equalsOrNil(value1: any, value2: any): boolean;
+/**
+ * remove elements from an array
+ *
+ * @return the removed elements
+ * @param array the array on which elements will be removed
+ * @param predicate the selection predicate
+ */
+export declare function removeAll<T>(array: T[], predicate: (value: T) => boolean): T[];
+/**
+ * remove the first element from an array
+ *
+ * @return the removed element
+ * @param array the array on which the element will be removed
+ * @param predicate the selection predicate
+ */
+export declare function remove<T>(array: T[], predicate: (value: T) => boolean): T;
+export declare function capitalizeFirstLetter(value: string): string;
+export declare function uncapitalizeFirstLetter(value: string): string;
+export declare function booleanToString(value: any, opts?: {
+    yesLabel: string;
+    noLabel: string;
+}): string;
+export declare function splitByProperty<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[], propertyName: keyof T | string): M;
+export declare function splitById<T, M extends KeyValueType<T> = KeyValueType<T>>(array: T[] | readonly T[]): M;
+/**
+ * Split an array, into a map of array, group by property
+ */
+export declare function collectByProperty<T>(values: T[], propertyName: keyof T): KeyValueType<T[]>;
+/**
+ * Split an array into chunks with fixed size
+ */
+export declare function splitArrayInChunks<T = any>(value: T[], chunkSize: number): T[][];
+/**
+ * Determines if two objects or two values are equivalent.
+ *
+ * Two objects or values are considered equivalent if at least one of the following is true:
+ *
+ * * Both objects or values pass `===` comparison.
+ * * Both objects or values are of the same type and all of their properties are equal by
+ *   comparing them with `equals`.
+ *
+ * @param o1 Object or value to compare.
+ * @param o2 Object or value to compare.
+ * @returns true if arguments are equal.
+ */
+export declare function equals(o1: any, o2: any): boolean;
+export declare class Beans {
+    /**
+     * Deep clone.
+     * See https://github.com/pvorb/clone
+     */
+    static clone: any;
+    /**
+     * Copy a source object, by including only properties of the given dataType.
+     * IMPORTANT: extra properties that are NOT in the targetClass are NOT copied.
+     *
+     * @param source The source object to copy
+     * @param dataType the class to use as target class
+     * @param keys The keys to copy. If empty, will copy only NOT optional properties from the dataType
+     */
+    static copy<T>(source: T, dataType: new () => T, keys?: KeysEnum<T>): T;
+    /**
+     * Says if an object all all properties to nil
+     */
+    static isEmpty<T>(data: T, keys?: KeysEnum<T> | string[], opts?: {
+        blankStringLikeEmpty?: boolean;
+    }): boolean;
+    static collectById<T>(array: T[]): KeyValueType<T[]>;
+    static collectByProperty: typeof collectByProperty;
+}
+export declare function findParentWithClass(elem: HTMLElement, className: string): HTMLElement;
+export declare function intersectArrays<T = any>(values: T[][]): T[];
+export declare function noHtml(value: string): string;
+/**
+ * Interpolates a string by replacing placeholders with corresponding values from the provided object.
+ *
+ * @param {string} message - The string containing placeholders enclosed in double curly braces (e.g., {{key}}).
+ * @param {Record<string, any>} interpolateParams - An object containing key-value pairs for interpolation.
+ * @return {string} The interpolated string with placeholders replaced by corresponding values, or the original string if no placeholders are matched.
+ */
+export declare function interpolateString(message: string, interpolateParams: Record<string, any>): string;
+/**
+ *
+ * Transforms a value (typically a string) to a number.
+ * Intended to be used as a transform function of an input.
+ * Should return n=undefined when for a nil input
+ * @param value Value to be transformed.
+ * @param fallbackValue Value to use if the provided value can't be parsed as a number.
+ *
+ *  @usageNotes
+ *  ```ts
+ *  @Input({ transform: numberAttribute }) id!: number;
+ *  ```
+ *
+ * @publicApi
+ */
+export declare function numberOrNilAttribute(value: unknown, fallbackValue?: number): number | undefined | null;
+/**
+ * Formats a given number according to the specified options.
+ *
+ * @param {number} val - The number to be formatted.
+ * @param {Intl.NumberFormatOptions & { fixedDecimals?: number }} [opts] - An optional object containing formatting options. It can include standard `Intl.NumberFormatOptions` properties and an additional `fixedDecimals` property to specify the number of fixed decimal places.
+ * @return {string} The formatted number as a string, based on the provided options.
+ */
+export declare function numberToString(val: number, opts?: Intl.NumberFormatOptions & {
+    fixedDecimals?: number;
+}): string;