@gipisistemas/ng-core 1.1.0 → 1.1.1

package/shared/gipi-components/dropdown-menu/dropdown-menu.component.d.ts

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { GIPIPopoverTrigger } from '../popover/shared/popover-trigger';
+export declare class GIPIDropdownMenuComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    elementRef: ElementRef;
+    private _name;
+    popoverTrigger: GIPIPopoverTrigger;
+    id: number | string;
+    name: string;
+    label: string;
+    ariaLabel: string;
+    placeholder: string;
+    disabled: boolean;
+    required: boolean;
+    showTrigger: boolean;
+    private _trigger;
+    set trigger(value: number);
+    get trigger(): number;
+    onKeydown: EventEmitter<KeyboardEvent>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClick: EventEmitter<Event>;
+    onOpenPopover: EventEmitter<void>;
+    onClosePopover: EventEmitter<void>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    onInputFocus(event: Event): void;
+    onInputBlur(event: Event): void;
+    onInputClick(event: Event): void;
+    togglePopover(): void;
+    showPopover(): void;
+    closePopover(): void;
+    onResize(event: UIEvent): void;
+}

package/shared/gipi-components/expansion-panel/expansion-panel.component.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+export declare class GIPIExpansionPanelComponent implements OnInit {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    icon: string;
+    svgIcon: string;
+    iconSize: string | number;
+    panelTitle: string;
+    isExpanded: boolean;
+    startExpanded: boolean;
+    disabled: boolean;
+    expanded: EventEmitter<boolean>;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    emitExpanded(value: boolean): void;
+}

package/shared/gipi-components/file-drag-and-drop/file-drag-and-drop.component.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ConfirmationService } from '../../../core/services/confirmation.service';
+import { MessageService } from '../../../core/services/message.service';
+export declare class GIPIFileDragAndDropComponent implements ControlValueAccessor, OnInit {
+    private _messageService;
+    private _confirmationService;
+    _elementRef: ElementRef;
+    files: any[];
+    color: string;
+    icon: string;
+    iconFile: string;
+    iconDeleteFile: string;
+    svgIcon: string;
+    svgIconFile: string;
+    svgIconDeleteFile: string;
+    iconSize: number;
+    iconSizeFile: number;
+    multiple: boolean;
+    disabled: boolean;
+    onlyExtensions: string[];
+    verifyHasAdded: boolean;
+    legendFieldset: string;
+    listFileVisible: boolean;
+    removingFiles: boolean;
+    fileChange: EventEmitter<any>;
+    constructor(_messageService: MessageService, _confirmationService: ConfirmationService);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    onFileChange(pFileList: File[]): void;
+    onDeleteFile(file: File): void;
+    onClearInputFile(emitFileChange: boolean): boolean;
+    openConfirmDialogRemoveFile(file: File, index: number): void;
+    private _validateCountFiles;
+    private _validateHasAdded;
+    private _validateExtensionFile;
+    private addSuccessMessage;
+    private addErrorMessage;
+}

package/shared/gipi-components/file-drag-and-drop/shared/file-drag-and-drop.directive.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@angular/core';
+export declare class GIPIFileDragAndDropDirective {
+    filesChangeEmiter: EventEmitter<File[]>;
+    disabled: boolean;
+    background: string;
+    borderStyle: string;
+    borderColor: string;
+    borderRadius: string;
+    constructor();
+    onDragOver(evt: any): void;
+    onDragLeave(evt: any): void;
+    onDrop(evt: any): void;
+}

package/shared/gipi-components/footer/footer.component.d.ts

@@ -0,0 +1,5 @@
+import { OnInit } from '@angular/core';
+export declare class GIPIFooterComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+}

package/shared/gipi-components/form-field/form-field.component.d.ts

@@ -0,0 +1,61 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { CurrencyMaskConfig } from 'ngx-currency';
+export declare class GIPIFormFieldComponent implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    elementRef: ElementRef;
+    private _name;
+    id: number | string;
+    name: string;
+    label: string;
+    ariaLabel: string;
+    placeholder: string;
+    readonly: boolean;
+    disabled: boolean;
+    required: boolean;
+    showClear: boolean;
+    showSearch: boolean;
+    showTrigger: boolean;
+    type: 'text' | 'email' | 'number' | 'password' | 'url' | 'tel' | 'select' | 'search' | 'currency';
+    min: number;
+    max: number;
+    maxLength: number;
+    mask: string | undefined | null;
+    pattern: string;
+    optionsCurrency: Partial<CurrencyMaskConfig>;
+    private _model;
+    set model(value: any);
+    get model(): any;
+    private _value;
+    set value(value: any);
+    get value(): any;
+    private _trigger;
+    set trigger(value: number);
+    get trigger(): number;
+    inputRef: ElementRef;
+    onKeydown: EventEmitter<KeyboardEvent>;
+    onKeydownEnter: EventEmitter<KeyboardEvent>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClick: EventEmitter<Event>;
+    onClear: EventEmitter<Event>;
+    onSearch: EventEmitter<Event>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(value: boolean): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    onInputFocus(event: Event): void;
+    onInputBlur(event: Event): void;
+    onInputClick(event: Event): void;
+    onButtonClearClick(event: Event): void;
+    onButtonSearchClick(event: Event): void;
+    /**
+     * Seta o foco no inputRef
+     */
+    focus(): void;
+}

package/shared/gipi-components/helpful-tip/helpful-tip.component.d.ts

@@ -0,0 +1,13 @@
+import { ChangeDetectorRef, ElementRef, OnInit } from '@angular/core';
+export declare class GIPIHelpfulTipComponent implements OnInit {
+    private _changeDetectorRef;
+    elementRef: ElementRef;
+    private _name;
+    id: number | string;
+    name: string;
+    private _tooltip;
+    set tooltip(value: string);
+    get tooltip(): string;
+    constructor(_changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    ngOnInit(): void;
+}

package/shared/gipi-components/infinite-scroll/infinite-scroll.directive.d.ts

@@ -0,0 +1,27 @@
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { AfterViewInit, EventEmitter, NgZone, OnDestroy, OnInit } from '@angular/core';
+/**
+ * Esta diretiva foi reescrita utilizando se do projeto a seguir
+ * https://github.com/HaidarZ/ng-mat-select-infinite-scroll
+ */
+export declare class GIPIInfiniteScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    private _cdkVirtualScrollViewport;
+    private _ngZone;
+    private _panel;
+    private _thrPx;
+    private _thrPc;
+    private _destroyed$;
+    infiniteScrollDistance: string;
+    infiniteScrollThrottle: number;
+    infiniteScrollDisabled: boolean;
+    infiniteScrollcomplete: boolean;
+    infiniteScrollOptionHeight: number;
+    scrolled: EventEmitter<'up' | 'down'>;
+    constructor(_cdkVirtualScrollViewport: CdkVirtualScrollViewport, _ngZone: NgZone);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    evaluateThreshold(): void;
+    registerScrollListener(): void;
+    handleScrollEvent(event: any): void;
+}

package/shared/gipi-components/input-checkbox/input-checkbox.component.d.ts

@@ -0,0 +1,28 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+export declare class GIPIInputCheckboxComponent implements ControlValueAccessor, OnInit {
+    private _changeDetectorRef;
+    private _name;
+    id: number | string;
+    name: string;
+    label: string;
+    disabled: boolean;
+    disableRipple: boolean;
+    labelPosition: 'before' | 'after';
+    required: boolean;
+    indeterminate: boolean;
+    private _value;
+    set value(val: any);
+    get value(): any;
+    change: EventEmitter<MatCheckboxChange>;
+    indeterminateChange: EventEmitter<boolean>;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    setDisabledState(val: boolean): void;
+}

package/shared/gipi-components/input-currency/input-currency.component.d.ts

@@ -0,0 +1,48 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { CurrencyMaskConfig } from 'ngx-currency';
+export declare class GIPIInputCurrencyComponent implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    elementRef: ElementRef;
+    private _name;
+    id: number | string;
+    name: string;
+    label: string;
+    ariaLabel: string;
+    placeholder: string;
+    readonly: boolean;
+    disabled: boolean;
+    required: boolean;
+    min: number;
+    max: number;
+    maxLength: number;
+    options: Partial<CurrencyMaskConfig>;
+    private _model;
+    set model(value: any);
+    get model(): any;
+    private _value;
+    set value(value: any);
+    get value(): any;
+    inputCurrencyRef: ElementRef;
+    onKeydown: EventEmitter<KeyboardEvent>;
+    onKeydownEnter: EventEmitter<KeyboardEvent>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClick: EventEmitter<Event>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(value: boolean): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    onInputFocus(event: Event): void;
+    onInputBlur(event: Event): void;
+    onInputClick(event: Event): void;
+    /**
+     * Seta o foco no inputRef
+     */
+    focus(): void;
+}

package/shared/gipi-components/input-monthpicker/input-monthpicker.component.d.ts

@@ -0,0 +1,89 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { GIPINgConfig } from '../../api/gipi-ng-config';
+export declare class GIPIInputMonthPickerComponent implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    private _config;
+    private _name;
+    private _initialYear;
+    set initialYear(value: number);
+    get initialYear(): number;
+    private _yearArrays;
+    set yearArrays(value: number[]);
+    get yearArrays(): number[];
+    _now: Date;
+    _currentMonth: number;
+    _currentYear: number;
+    _overlayVisible: boolean;
+    monthArrays: number[];
+    monthNames: string[];
+    internalCalendarView: 'month' | 'year';
+    inputFieldValue: string;
+    id: string | number;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    disabled: boolean;
+    loading: boolean;
+    required: boolean;
+    showOnFocus: boolean;
+    minDate: Date;
+    maxDate: Date;
+    private _calendarView;
+    set calendarView(value: 'month' | 'year');
+    get calendarView(): 'month' | 'year';
+    private _value;
+    set value(value: Date);
+    get value(): Date;
+    onClose: EventEmitter<Event>;
+    onMonthChange: EventEmitter<string>;
+    onYearChange: EventEmitter<string>;
+    onKeydown: EventEmitter<KeyboardEvent>;
+    onKeydownEnter: EventEmitter<KeyboardEvent>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClick: EventEmitter<Event>;
+    inputMonthPickerRef: HTMLInputElement;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _config: GIPINgConfig);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    setDisabledState(val: boolean): void;
+    private _generateYears;
+    clickToggleCalendar(currentView?: 'month' | 'year'): void;
+    clickPrev(): void;
+    clickNext(): void;
+    /**
+     * Chamado quando o mês é alterado
+     * @param month mês selecionado no calendário de meses
+     */
+    monthChanged(month: number): void;
+    /**
+     * Chamado quando o ano é alterado
+     * @param year ano selecionado no calendário de anos
+     */
+    yearChanged(year: number): void;
+    /**
+     *  Chamar quando mês ou ano mudou
+     * @param month número do mês 0-11
+     * @param year ano exemplo: 1995
+     */
+    private _monthOrYearChanged;
+    isMonthSelected(month: number): boolean;
+    isMonthDisabled(month: number): boolean;
+    isYearSelected(year: number): boolean;
+    isYearDisabled(year: number): boolean;
+    onInputKeydown(event: KeyboardEvent): void;
+    onInputKeyup(event: KeyboardEvent): void;
+    onInputFocus(event: Event): void;
+    onInputBlur(event: Event): void;
+    onInputClick(event: Event): void;
+    onButtonShowMonthpicker(): void;
+    private _showOverlay;
+    private _hideOverlay;
+    toogleOverlay(): void;
+}

package/shared/gipi-components/input-select/input-select.component.d.ts

@@ -0,0 +1,120 @@
+import { ChangeDetectorRef, EventEmitter, OnInit, TrackByFunction } from '@angular/core';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { PageDTO } from '../../../core/models/dto/page.dto';
+import { GIPIFormFieldComponent } from '../form-field/form-field.component';
+import { GIPIOverlayComponent } from '../overlay/overlay.component';
+export interface AddChange<T> {
+    values: T | T[];
+    selectedAll?: boolean;
+}
+export declare class GIPIInputSelectComponent<T> implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    private _name;
+    private _cache;
+    private _pageModel;
+    private _onDestroy;
+    _itemSizeScrollViewport: number;
+    _totalOptions: number;
+    _overlayVisible: boolean;
+    _formControlSearch: FormControl;
+    inputFieldValue: string;
+    inputFieldValueSelected: number;
+    toggleAllCheckboxChecked: boolean;
+    toggleAllCheckboxIndeterminate: boolean;
+    isLoading: number;
+    formfieldSelectSearchInput: GIPIFormFieldComponent;
+    formFieldSelect: GIPIFormFieldComponent;
+    overlaySelect: GIPIOverlayComponent;
+    private cdkVirtualScrollViewPort;
+    id: string | number;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    labelSelectAll: string;
+    multiple: boolean;
+    showClear: boolean;
+    showOnFocus: boolean;
+    hideOnEscape: boolean;
+    showSelectAll: boolean;
+    showFooter: boolean;
+    infiniteScroll: boolean;
+    showSearch: boolean;
+    required: boolean;
+    property: string;
+    trackBy: string;
+    appendTo: any;
+    propertyFn: (obj: T) => string;
+    nextBatchFn: (researchField: string, page: number, paramNextBatch?: any) => Promise<PageDTO<T>>;
+    pageSize: number;
+    enableClearOnEscapePressed: boolean;
+    private _disabled;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    private _loading;
+    set loading(value: boolean);
+    get loading(): boolean;
+    private _paramNextBatch;
+    set paramNextBatch(val: any);
+    get paramNextBatch(): any;
+    private _value;
+    set value(value: T | T[]);
+    get value(): T | T[];
+    private _options;
+    set options(val: T[]);
+    get options(): T[];
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClose: EventEmitter<Event>;
+    onSelectChange: EventEmitter<T | T[]>;
+    onOpenedChange: EventEmitter<boolean>;
+    onSearchChange: EventEmitter<string>;
+    onAddChange: EventEmitter<AddChange<T>>;
+    get scrollViewportHeight(): number;
+    get valueSearch(): string;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    trackByOption: TrackByFunction<T>;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    setDisabledState(val: boolean): void;
+    compareFn(f1: T, f2: T): boolean;
+    getPropertyValue(entity: T): string;
+    private _getValue;
+    onInputFocus(event: Event): void;
+    onInputClick(): void;
+    onInputBlur(event: Event): void;
+    onInputKeydown(event: any): void;
+    onClearOptionsClick(event: Event): void;
+    showOverlay(): void;
+    hideOverlay(): void;
+    toggleOverlay(): void;
+    onScroll(): Promise<void>;
+    onButtonSelectOptionClick(option: T): void;
+    indeterminateAllCheckbox(): void;
+    optionCheckboxIsChecked(option: T): boolean;
+    onClickSelectAllByOption(): void;
+    onChangeToggleAllCheckbox(): void;
+    onClickAddOptions(): void;
+    private _disableInputSearch;
+    private _searchChange;
+    /**
+     * Focaliza o input de pesquisa
+     */
+    _searchSelectInputFocus(): void;
+    /**
+     * Redefine o valor do input de pesquisa atual
+     * @param focus se deve focar após a redefinição
+     */
+    _searchSelectInputReset(focus?: boolean): void;
+    /**
+     * Manipula o evento de tecla pressionada.
+     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.
+     * @param event
+     */
+    onInputSearchKeydown(event: KeyboardEvent): void;
+}

package/shared/gipi-components/input-select-enum/input-select-enum.component.d.ts

@@ -0,0 +1,65 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { GIPIFormFieldComponent } from '../form-field/form-field.component';
+import { GIPIPopoverTrigger } from '../popover/shared/popover-trigger';
+export declare class GIPIInputSelectEnumComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    private _name;
+    _enumList: any[];
+    _itemSizeScrollViewport: number;
+    _lastOptionSelected: any;
+    formFieldSelectEnum: GIPIFormFieldComponent;
+    popoverTrigger: GIPIPopoverTrigger;
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    required: boolean;
+    private _disabled;
+    set disabled(value: any);
+    get disabled(): any;
+    private _loading;
+    set loading(value: any);
+    get loading(): any;
+    private _multiple;
+    set multiple(value: any);
+    get multiple(): any;
+    private _showOnFocus;
+    set showOnFocus(value: any);
+    get showOnFocus(): any;
+    private _hideOnEscape;
+    set hideOnEscape(value: any);
+    get hideOnEscape(): any;
+    enum: any;
+    sort: (a: any, b: any) => number;
+    valuesExclud: string[];
+    valuesOmit: string[];
+    private _value;
+    set value(value: any);
+    get value(): any;
+    selectionChange: EventEmitter<string>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onOpenedChange: EventEmitter<boolean>;
+    get optionSelected(): string;
+    get scrollViewportHeight(): number;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    validateOmitByKey(key: string): boolean;
+    showPopover(): void;
+    closePopover(): void;
+    onInputFocus(event: Event): void;
+    onInputClick(event: Event): void;
+    onInputBlur(event: Event): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    onButtonSelectOptionClick(key: string): void;
+    onWindowResize(event: UIEvent): void;
+}

package/shared/gipi-components/input-select-listbox/input-select-listbox.component.d.ts

@@ -0,0 +1,85 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit, Renderer2, TrackByFunction } from '@angular/core';
+import { ControlValueAccessor, NgModel } from '@angular/forms';
+import { MatRadioChange } from '@angular/material/radio';
+import { PageDTO } from '../../../core/models/dto/page.dto';
+import { GIPIFormFieldComponent } from '../form-field/form-field.component';
+import { GIPIInputSelectComponent } from '../input-select/input-select.component';
+import { GIPIOverlayComponent } from '../overlay/overlay.component';
+export declare type FilterType = 'TO_OMIT' | 'ALL' | 'BY_SELECTION';
+export interface ApplyChange<T> {
+    filterType: FilterType;
+    values: T[];
+}
+export declare class GIPIInputSelectListboxComponent<T> implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    private _elementRef;
+    private _renderer;
+    private _name;
+    _isOverlayChildrenClicked: boolean;
+    _overlayVisible: boolean;
+    _selectEntityOpened: boolean;
+    _radioValue: FilterType;
+    formFieldSelectListbox: GIPIFormFieldComponent;
+    overlaySelectListbox: GIPIOverlayComponent;
+    inputSelect: GIPIInputSelectComponent<T>;
+    id: string | number;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    placeholderSelected: string;
+    placeholderSearch: string;
+    multiple: boolean;
+    disabled: boolean;
+    loading: boolean;
+    readonly: boolean;
+    required: boolean;
+    hideFilterType: boolean;
+    showOnFocus: boolean;
+    hideOnEscape: boolean;
+    showSearch: boolean;
+    property: string;
+    trackBy: string;
+    propertyFn: (obj: T) => string;
+    nextBatchFn: (researchField: string, page: number, paramNextBatch?: any) => Promise<PageDTO<T>>;
+    _value: T[];
+    set value(value: T[]);
+    get value(): T[];
+    _options: T[];
+    set options(val: T[]);
+    get options(): T[];
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onClose: EventEmitter<Event>;
+    onOpenedChange: EventEmitter<boolean>;
+    onSelectChange: EventEmitter<T[]>;
+    onApply: EventEmitter<ApplyChange<T>>;
+    get valueInput(): string;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef, _renderer: Renderer2);
+    ngOnInit(): void;
+    trackByOption: TrackByFunction<T>;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    setDisabledState(val: boolean): void;
+    getPropertyValue(entity: T): string;
+    private _getValue;
+    onInputFocus(event: Event): void;
+    onInputClick(): void;
+    onInputBlur(event: Event): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    showOverlay(): void;
+    hideOverlay(): void;
+    toggleOverlay(): void;
+    onSelectEntityOpened(isOpened: boolean): void;
+    onChangeInputSelect(values: T[], ngModelRadioGroup: NgModel): void;
+    resizeOverlay(event: UIEvent): void;
+    documentClick: () => boolean;
+    onRemoveOptionsSelected(option: T, inputSelect: GIPIInputSelectComponent<T>): void;
+    onChangeRadioGroup(radioChange: MatRadioChange, ngModel: NgModel): void;
+    onClickRadioButton(radioValue: FilterType, ngModel: NgModel): void;
+    onClickClear(inputSelect?: GIPIInputSelectComponent<T>): void;
+    onClickApply(): void;
+}