@gipisistemas/ng-core 1.1.0 → 1.1.2

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

@@ -0,0 +1,77 @@
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import { ChangeDetectorRef, ElementRef, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { MatFormField, MatOption, MatSelect } from '@angular/material';
+import { BehaviorSubject, Observable } from 'rxjs';
+export declare class GIPIInputSearchComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {
+    matSelect: MatSelect;
+    changeDetectorRef: ChangeDetectorRef;
+    private _viewportRuler;
+    matOption: MatOption;
+    matFormField: MatFormField;
+    get value(): string;
+    private _lastExternalInputValue;
+    _options$: BehaviorSubject<QueryList<MatOption>>;
+    set _options(_options: QueryList<MatOption>);
+    get _options(): QueryList<MatOption>;
+    private optionsList$;
+    private optionsLength$;
+    _formControl: FormControl;
+    _showNoEntriesFound$: Observable<boolean>;
+    private _onDestroy;
+    private activeDescendant;
+    placeholderLabel: string;
+    clearSearchInput: boolean;
+    searching: boolean;
+    disableInitialFocus: boolean;
+    enableClearOnEscapePressed: boolean;
+    /**
+     * Impede que a chave home/end seja propagada para mat-select,
+     * permitindo mover o cursor dentro da entrada de pesquisa em vez de navegar pelas opções
+     */
+    preventHomeEndKeyPropagation: boolean;
+    disableScrollToActiveOnOptionsChanged: boolean;
+    hideClearSearchButton: boolean;
+    searchSelectInput: ElementRef;
+    innerSelectSearch: ElementRef;
+    get isInsideMatOption(): boolean;
+    constructor(matSelect: MatSelect, changeDetectorRef: ChangeDetectorRef, _viewportRuler: ViewportRuler, matOption?: MatOption, matFormField?: MatFormField);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onTouched: Function;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: Function): void;
+    writeValue(value: string): void;
+    /**
+     * Manipula o evento de tecla pressionada com MatSelect.
+     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.
+     * @param event
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Manipula o evento de ativação de chave com MatSelect.
+     * Permite, por ex. o anúncio do Descendente atualmente ativo por leitores de tela.
+     */
+    _handleKeyup(event: KeyboardEvent): void;
+    onBlur(): void;
+    /**
+     * Focaliza o campo de entrada de pesquisa
+     */
+    _focus(): void;
+    /**
+     * Redefine o valor de pesquisa atual
+     * @param focus se deve focar após a redefinição
+     */
+    _reset(focus?: boolean): void;
+    /**
+     *  Defina a largura do innerSelectSearch para ajustar até mesmo as barras de rolagem personalizadas
+     *  E apoiar todos os sistemas de operação
+     */
+    updateInputWidth(): void;
+    /**
+     * Determine o deslocamento para o comprimento que pode ser causado pelo matOption opcional usado como uma entrada de pesquisa.
+     */
+    private getOptionsLengthOffset;
+    private unselectActiveDescendant;
+}

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

@@ -0,0 +1,66 @@
+import { ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges, TrackByFunction } from '@angular/core';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { Subscription } from 'rxjs';
+import { AbstractModel, PageDTO } from '../../../core';
+export declare class GIPIInputSelectPagedComponent<T> implements OnInit, OnChanges, ControlValueAccessor, OnDestroy {
+    private _changeDetectorRef;
+    private _name;
+    valueSearchCtrl: FormControl;
+    page: PageDTO<T>;
+    totalOptions: number;
+    subscriptions: Subscription[];
+    searching: boolean;
+    private matSelect;
+    private cdkVirtualScrollViewPort;
+    id: number | string;
+    name: string;
+    label: string;
+    ariaLabel: string;
+    placeholder: string;
+    disabled: boolean;
+    required: boolean;
+    hideFieldSearch: boolean;
+    showClear: boolean;
+    debounceTime: number;
+    valuesExclud: T[];
+    classSelectPanel: string;
+    trackyBy: string;
+    infiniteScroll: boolean;
+    property: string;
+    propertyFn: (obj: T) => string;
+    nextBatchFn: (researchField: string, page: number, paramNextBatch?: any) => Promise<PageDTO<T>>;
+    private _paramNextBatch;
+    set paramNextBatch(val: any);
+    get paramNextBatch(): any;
+    private _model;
+    set model(value: T);
+    get model(): T;
+    private _options;
+    set options(val: T[]);
+    get options(): T[];
+    modelChange: EventEmitter<any>;
+    selectionChange: EventEmitter<any>;
+    searchChange: EventEmitter<string>;
+    openedChange: EventEmitter<boolean>;
+    get scrollViewportHeight(): number;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): 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: AbstractModel, f2: AbstractModel): boolean;
+    getPropertyValue(entity: any): string;
+    getValue(entity: any, property: string): string;
+    onSelectionChange(entity: T): void;
+    onSearchChange(value: string): void;
+    onLoadMoreOptions(isInfiniteScroll: boolean, isOpened?: boolean): Promise<void>;
+    showClearOptionButton(): boolean;
+    haveSelected(): boolean;
+    removeOption(): void;
+}

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

@@ -0,0 +1,53 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatRadioChange } from '@angular/material/radio';
+import { GIPIFormFieldComponent } from '../form-field/form-field.component';
+import { GIPIPopoverTrigger } from '../popover/shared/popover-trigger';
+export declare class GIPIInputSelectRadioComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    private _name;
+    _enumList: any[];
+    formFieldSelectRadio: GIPIFormFieldComponent;
+    popoverTrigger: GIPIPopoverTrigger;
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    required: boolean;
+    disabled: boolean;
+    loading: boolean;
+    showOnFocus: boolean;
+    hideOnEscape: boolean;
+    hideOnClick: boolean;
+    enum: any;
+    sort: (a: any, b: any) => number;
+    valuesExclud: string[];
+    valuesOmit: string[];
+    _value: any;
+    set value(value: any);
+    get value(): any;
+    selectionChange: EventEmitter<string>;
+    onFocus: EventEmitter<Event>;
+    onBlur: EventEmitter<Event>;
+    onOpenedChange: EventEmitter<boolean>;
+    get optionSelected(): string;
+    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;
+    changeRadioGroup({ value }: MatRadioChange): 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;
+    onWindowResize(event: UIEvent): void;
+}

package/shared/gipi-components/layout-grid/col.directive.d.ts

@@ -0,0 +1,38 @@
+import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { GIPIRowDirective } from './row.directive';
+export interface EmbeddedProperty {
+    span?: number;
+    pull?: number;
+    push?: number;
+    offset?: number;
+    order?: number;
+}
+export declare class GIPIColDirective implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private elementRef;
+    GIPIRowDirective: GIPIRowDirective;
+    renderer: Renderer2;
+    private _classMap;
+    private _destroy$;
+    hostFlexStyle: string | null;
+    GIPIFlex: string | number | null;
+    GIPISpan: string | number | null;
+    GIPIOrder: string | number | null;
+    GIPIOffset: string | number | null;
+    GIPIPush: string | number | null;
+    GIPIPull: string | number | null;
+    GIPIXs: string | number | EmbeddedProperty | null;
+    GIPISm: string | number | EmbeddedProperty | null;
+    GIPIMd: string | number | EmbeddedProperty | null;
+    GIPILg: string | number | EmbeddedProperty | null;
+    GIPIXl: string | number | EmbeddedProperty | null;
+    GIPIXXl: string | number | EmbeddedProperty | null;
+    constructor(elementRef: ElementRef, GIPIRowDirective: GIPIRowDirective, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _setHostClassMap;
+    private _setHostFlexStyle;
+    private _parseFlex;
+    private _generateClass;
+}

package/shared/gipi-components/layout-grid/row.directive.d.ts

@@ -0,0 +1,28 @@
+import { MediaMatcher } from '@angular/cdk/layout';
+import { Platform } from '@angular/cdk/platform';
+import { AfterViewInit, ElementRef, NgZone, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { GIPIIndexableObject } from '../../../core/types/ng-class.type';
+import { GIPIBreakpointService } from './services/breakpoint.service';
+export declare type GIPIJustify = 'start' | 'end' | 'center' | 'space-around' | 'space-between' | 'space-evenly';
+export declare type GIPIAlign = 'top' | 'middle' | 'bottom';
+export declare class GIPIRowDirective implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    elementRef: ElementRef;
+    renderer: Renderer2;
+    mediaMatcher: MediaMatcher;
+    ngZone: NgZone;
+    platform: Platform;
+    private _breakpointService;
+    private readonly _destroy$;
+    readonly actualGap$: ReplaySubject<[number, number]>;
+    GIPIAlign: GIPIAlign | null;
+    GIPIJustify: GIPIJustify | null;
+    GIPIGap: string | number | GIPIIndexableObject | [number, number] | [GIPIIndexableObject, GIPIIndexableObject] | null;
+    constructor(elementRef: ElementRef, renderer: Renderer2, mediaMatcher: MediaMatcher, ngZone: NgZone, platform: Platform, _breakpointService: GIPIBreakpointService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _setGapStyle;
+    private _getGap;
+}

package/shared/gipi-components/layout-grid/services/breakpoint.service.d.ts

@@ -0,0 +1,30 @@
+import { MediaMatcher } from '@angular/cdk/layout';
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { GIPIResizeService } from './resize.service';
+export declare enum BreakpointEnum {
+    xl = "xl",
+    lg = "lg",
+    md = "md",
+    sm = "sm",
+    xs = "xs"
+}
+export declare type BreakpointMap = {
+    [key in BreakpointEnum]: string;
+};
+export declare type BreakpointBooleanMap = {
+    [key in BreakpointEnum]: boolean;
+};
+export declare type GridBreakpointKey = keyof typeof BreakpointEnum;
+export declare const gridResponsiveMap: BreakpointMap;
+export declare const siderResponsiveMap: BreakpointMap;
+export declare class GIPIBreakpointService implements OnDestroy {
+    private resizeService;
+    private mediaMatcher;
+    private destroy$;
+    constructor(resizeService: GIPIResizeService, mediaMatcher: MediaMatcher);
+    ngOnDestroy(): void;
+    subscribe(breakpointMap: BreakpointMap): Observable<BreakpointEnum>;
+    subscribe(breakpointMap: BreakpointMap, fullMap: true): Observable<BreakpointBooleanMap>;
+    private matchMedia;
+}

package/shared/gipi-components/layout-grid/services/resize.service.d.ts

@@ -0,0 +1,17 @@
+import { NgZone, OnDestroy, RendererFactory2 } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare class GIPIResizeService implements OnDestroy {
+    private ngZone;
+    private rendererFactory2;
+    private readonly resizeSource$;
+    private listeners;
+    private renderer;
+    private disposeHandle;
+    private handler;
+    constructor(ngZone: NgZone, rendererFactory2: RendererFactory2);
+    ngOnDestroy(): void;
+    subscribe(): Observable<void>;
+    unsubscribe(): void;
+    private registerListener;
+    private unregisterListener;
+}

package/shared/gipi-components/month-year-picker/calendar-month-year/calendar-month-year.component.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MonthYearPickerComponent } from '../month-year-picker.component';
+export declare class CalendarMonthYearComponent implements AfterViewInit, OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _subscriptions;
+    _animationState: 'enter' | 'void';
+    _animationDone: Subject<void>;
+    monthYearPicker: MonthYearPickerComponent;
+    isShowYears: boolean;
+    years: Array<number>;
+    months: Array<string>;
+    _calendarView: 'both' | 'year';
+    _locale: string;
+    _year: number;
+    _month: number;
+    _multiple: boolean;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _startExitAnimation(): void;
+    decrement(): void;
+    increment(): void;
+    selectMonth(index: number): void;
+    isSelectedMonth(monthIndex: number): boolean;
+    isCurrentMonth(monthIndex: number): boolean;
+    isDisabledMonth(index: number): boolean;
+    /** Years */
+    toggleShowYears(): void;
+    private _renderYears;
+    get periodButtonLabel(): string;
+    selectYear(year: number): void;
+    isSelectedYear(year: number): boolean;
+    isCurrentYear(year: number): boolean;
+    isDisabledYear(index: number): boolean;
+}

package/shared/gipi-components/month-year-picker/mont-year-picker.module.d.ts

@@ -0,0 +1,2 @@
+export declare class MonthYearPickerModule {
+}

package/shared/gipi-components/month-year-picker/month-year-picker.component.d.ts

@@ -0,0 +1,104 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay, ScrollStrategy } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, NgZone, OnChanges, OnDestroy, OnInit, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Subject } from 'rxjs';
+export declare const GIPI_MONTH_YEAR_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+export declare function GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/** @docs-private */
+export declare const GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY;
+};
+export declare class MonthYear {
+    private _month;
+    private _year;
+    get date(): Date;
+    get month(): number;
+    get year(): number;
+    constructor(month?: number, year?: number);
+}
+export declare class MonthPickerModel {
+    selectedYearMoment: moment.Moment;
+    selectedYearText: string;
+    selectedMonthMoment: moment.Moment;
+    selectedMonthIndex: number;
+    selectedMonthYear: number;
+    months: Array<string>;
+    constructor();
+    updateYearText(): void;
+    selectMonth(index: number): void;
+    incrementYear(): void;
+    decrementYear(): void;
+}
+export declare class MonthYearPickerComponent implements OnInit, OnChanges, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    private _overlay;
+    private _ngZone;
+    private _viewContainerRef;
+    private _dir;
+    private _document;
+    inputMonthYearContentRef: ElementRef;
+    private _name;
+    private _scrollStrategy;
+    private _popupRef;
+    private _popupComponentRef;
+    private _focusedElementBeforeOpen;
+    private _backdropHarnessClass;
+    readonly _stateChanges: Subject<void>;
+    valueLabel: string;
+    model: MonthPickerModel;
+    id: string;
+    name: string;
+    label: string;
+    placeholder: string;
+    help: string;
+    locale: string;
+    year: number;
+    month: number;
+    multiple: boolean;
+    xPosition: 'start' | 'end';
+    yPosition: 'above' | 'below';
+    calendarView: 'both' | 'year';
+    private _opened;
+    get opened(): boolean;
+    set opened(value: boolean);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _min;
+    get min(): MonthYear;
+    set min(value: MonthYear);
+    private _max;
+    get max(): MonthYear;
+    set max(value: MonthYear);
+    private _value;
+    get value(): MonthYear;
+    set value(value: MonthYear);
+    openedStream: EventEmitter<void>;
+    closedStream: EventEmitter<void>;
+    onChange: Function;
+    onTouched: Function;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, scrollStrategy: any, _dir: Directionality, _document: any);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    writeValue(value: MonthYear): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onValueChange(month: number, year: number): void;
+    open(): void;
+    close(): void;
+    private _openAsPopup;
+    private _getConnectedOverlayOrigin;
+    private _createPopup;
+    private _destroyPopup;
+    private _setConnectedPositions;
+}

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

@@ -0,0 +1,21 @@
+import { EventEmitter, OnInit } from '@angular/core';
+export declare class GIPINotificationComponent implements OnInit {
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    buttonPadding: number | string;
+    iconWidth: number | string;
+    iconHeight: number | string;
+    icon: string;
+    svgIcon: string;
+    disabled: string;
+    loading: string;
+    tooltip: string;
+    onShowOverlay: EventEmitter<void>;
+    onClick: EventEmitter<MouseEvent>;
+    onFocus: EventEmitter<MouseEvent>;
+    onBlur: EventEmitter<MouseEvent>;
+    constructor();
+    ngOnInit(): void;
+}

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

@@ -0,0 +1,22 @@
+import { EventEmitter, OnInit } from '@angular/core';
+export declare class GIPINoveltiesComponent implements OnInit {
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    buttonPadding: number | string;
+    iconWidth: number | string;
+    iconHeight: number | string;
+    icon: string;
+    svgIcon: string;
+    disabled: string;
+    loading: string;
+    tooltip: string;
+    hasNovelties: boolean;
+    onShowOverlay: EventEmitter<void>;
+    onClick: EventEmitter<MouseEvent>;
+    onFocus: EventEmitter<MouseEvent>;
+    onBlur: EventEmitter<MouseEvent>;
+    constructor();
+    ngOnInit(): void;
+}

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

@@ -0,0 +1,113 @@
+import { AnimationEvent } from '@angular/animations';
+import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, QueryList, Renderer2, TemplateRef } from '@angular/core';
+import { GIPINgConfig } from '../../api/gipi-ng-config';
+import { GIPIOverlayService } from './shared/overlay-service';
+import { OverlayModeType, OverlayOptions, ResponsiveOverlayDirectionType, ResponsiveOverlayOptions } from './shared/overlay_options';
+/** @dynamic */
+export declare class GIPIOverlayComponent implements OnInit, AfterContentInit, OnDestroy {
+    private _document;
+    private _config;
+    private _zone;
+    elementRef: ElementRef;
+    renderer: Renderer2;
+    overlayService: GIPIOverlayService;
+    contentTemplate: TemplateRef<any> | undefined;
+    modalVisible: boolean;
+    isOverlayClicked: boolean;
+    isOverlayContentClicked: boolean;
+    scrollHandler: any;
+    documentClickListener: any;
+    documentResizeListener: any;
+    private documentKeyboardListener;
+    transformOptions: any;
+    private _window;
+    private _visible;
+    get visible(): boolean;
+    set visible(value: boolean);
+    private _mode;
+    get mode(): OverlayModeType | string;
+    set mode(value: OverlayModeType | string);
+    private _style;
+    get style(): any;
+    set style(value: any);
+    private _styleClass;
+    get styleClass(): string;
+    set styleClass(value: string);
+    private _contentStyle;
+    get contentStyle(): any;
+    set contentStyle(value: any);
+    private _contentStyleClass;
+    get contentStyleClass(): string;
+    set contentStyleClass(value: string);
+    private _target;
+    get target(): any;
+    set target(value: any);
+    private _appendTo;
+    get appendTo(): any;
+    set appendTo(value: any);
+    private _autoZIndex;
+    get autoZIndex(): boolean;
+    set autoZIndex(value: boolean);
+    private _baseZIndex;
+    get baseZIndex(): number;
+    set baseZIndex(value: number);
+    private _showTransitionOptions;
+    get showTransitionOptions(): string;
+    set showTransitionOptions(value: string);
+    private _hideTransitionOptions;
+    get hideTransitionOptions(): string;
+    set hideTransitionOptions(value: string);
+    private _listener;
+    get listener(): any;
+    set listener(value: any);
+    private _responsive;
+    get responsive(): ResponsiveOverlayOptions | undefined;
+    set responsive(val: ResponsiveOverlayOptions | undefined);
+    private _options;
+    get options(): OverlayOptions | undefined;
+    set options(val: OverlayOptions | undefined);
+    private _documentClick;
+    get documentClick(): () => boolean;
+    set documentClick(val: () => boolean);
+    visibleChange: EventEmitter<any>;
+    onBeforeShow: EventEmitter<any>;
+    onShow: EventEmitter<any>;
+    onBeforeHide: EventEmitter<any>;
+    onHide: EventEmitter<any>;
+    onAnimationStart: EventEmitter<any>;
+    onAnimationDone: EventEmitter<any>;
+    templates: QueryList<any> | undefined;
+    overlayViewChild: ElementRef | undefined;
+    contentViewChild: ElementRef | undefined;
+    get modal(): boolean;
+    get overlayMode(): string;
+    get overlayOptions(): OverlayOptions;
+    get overlayResponsiveOptions(): ResponsiveOverlayOptions;
+    get overlayResponsiveDirection(): ResponsiveOverlayDirectionType;
+    get overlayEl(): any;
+    get contentEl(): any;
+    get targetEl(): any;
+    constructor(_document: Document, _config: GIPINgConfig, _zone: NgZone, elementRef: ElementRef, renderer: Renderer2, overlayService: GIPIOverlayService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    show(overlay?: HTMLElement, isFocus?: boolean): void;
+    hide(overlay?: HTMLElement, isFocus?: boolean): void;
+    alignOverlay(): void;
+    onVisibleChange(visible: boolean): void;
+    onOverlayClick(event: any): void;
+    onOverlayContentClick(event: MouseEvent): void;
+    onOverlayContentAnimationStart(event: AnimationEvent): void;
+    onOverlayContentAnimationDone(event: AnimationEvent): void;
+    handleEvents(name: string, params: any): void;
+    bindListeners(): void;
+    unbindListeners(): void;
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    bindDocumentResizeListener(): void;
+    unbindDocumentResizeListener(): void;
+    bindDocumentKeyboardListener(): void;
+    unbindDocumentKeyboardListener(): void;
+}

package/shared/gipi-components/overlay/shared/overlay-service.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+export declare class GIPIOverlayService {
+    private clickSource;
+    clickObservable: Observable<any>;
+    add(event: any): void;
+}

package/shared/gipi-components/overlay/shared/overlay_options.d.ts

@@ -0,0 +1,50 @@
+import { AnimationEvent } from '@angular/animations';
+export declare type OverlayModeType = 'modal' | 'overlay' | undefined;
+export declare type ResponsiveOverlayDirectionType = 'center' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | undefined;
+export interface OverlayListenerOptions {
+    type?: 'scroll' | 'outside' | 'resize' | undefined;
+    mode?: OverlayModeType;
+    valid?: boolean;
+}
+export interface ResponsiveOverlayOptions {
+    style?: any;
+    styleClass?: string;
+    contentStyle?: any;
+    contentStyleClass?: string;
+    breakpoint?: string;
+    media?: string;
+    direction?: ResponsiveOverlayDirectionType;
+}
+export interface OverlayOnShowEvent {
+    overlay?: HTMLElement | undefined;
+    target?: HTMLElement | undefined;
+    mode?: OverlayModeType;
+}
+export interface OverlayOnBeforeShowEvent extends OverlayOnShowEvent {
+}
+export interface OverlayOnBeforeHideEvent extends OverlayOnBeforeShowEvent {
+}
+export interface OverlayOnHideEvent extends OverlayOnShowEvent {
+}
+export interface OverlayOptions {
+    mode?: OverlayModeType;
+    style?: any;
+    styleClass?: string;
+    contentStyle?: any;
+    contentStyleClass?: string;
+    target?: any;
+    appendTo?: 'body' | HTMLElement | undefined;
+    autoZIndex?: boolean;
+    baseZIndex?: number;
+    showTransitionOptions?: string;
+    hideTransitionOptions?: string;
+    hideOnEscape?: boolean;
+    listener?: (event: Event, options?: OverlayListenerOptions) => boolean | void;
+    responsive?: ResponsiveOverlayOptions | undefined;
+    onBeforeShow?: (event?: OverlayOnBeforeShowEvent) => void;
+    onShow?: (event?: OverlayOnShowEvent) => void;
+    onBeforeHide?: (event?: OverlayOnBeforeHideEvent) => void;
+    onHide?: (event?: OverlayOnHideEvent) => void;
+    onAnimationStart?: (event?: AnimationEvent) => void;
+    onAnimationDone?: (event?: AnimationEvent) => void;
+}