@gipisistemas/ng-core 1.0.67 → 1.0.68

package/shared/gipi-components/password-requeriments/password-requeriments.component.d.ts

@@ -0,0 +1,27 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class GIPIPasswordRequerimentsComponent implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    private _name;
+    id: number | string;
+    name: string;
+    disabled: boolean;
+    private _password;
+    set password(value: string);
+    get password(): string;
+    get isValidMinLength(): boolean;
+    get isValidMaxLength(): boolean;
+    get hasUppercase(): boolean;
+    get hasLowercase(): boolean;
+    get hasNumber(): boolean;
+    get hasBackspace(): boolean;
+    onValid: EventEmitter<boolean>;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(value: boolean): void;
+}

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

@@ -0,0 +1,133 @@
+import { ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { PopoverPanel } from './shared/popover-interfaces';
+import { PopoverPositionX, PopoverPositionY, PopoverScrollStrategy, PopoverTriggerEvent } from './shared/popover-types';
+export declare class GIPIPopoverComponent implements OnInit, PopoverPanel, OnDestroy {
+    private _elementRef;
+    zone: NgZone;
+    role: string;
+    private _popoverWidth;
+    private _positionX;
+    private _positionY;
+    private _triggerEvent;
+    private _scrollStrategy;
+    private _enterDelay;
+    private _leaveDelay;
+    private _overlapTrigger;
+    private _disableAnimation;
+    private _targetOffsetX;
+    private _targetOffsetY;
+    private _arrowOffsetX;
+    private _arrowWidth;
+    private _arrowColor;
+    private _closeOnClick;
+    private _focusTrapEnabled;
+    private _focusTrapAutoCaptureEnabled;
+    /** Objeto de configuração a ser passado para o ngClass do popover */
+    _classList: {
+        [key: string]: boolean;
+    };
+    /** Posição do popover */
+    containerPositioning: boolean;
+    /** Fechamento desabilitado no popover */
+    closeDisabled: boolean;
+    /** Objeto de configuração a ser passado para a seta ngStyle do popover */
+    popoverPanelStyles: {};
+    /** Objeto de configuração a ser passado para a seta ngStyle do popover */
+    popoverArrowStyles: {};
+    /** Objeto de configuração a ser passado para o conteúdo do popover ngStyle */
+    popoverContentStyles: {};
+    /** Emite o estado de animação atual sempre que muda. */
+    _onAnimationStateChange: EventEmitter<AnimationEvent>;
+    /** Largura do popover */
+    get popoverWidth(): string;
+    set popoverWidth(value: string);
+    /** Posição do popover no eixo X. */
+    get positionX(): PopoverPositionX;
+    set positionX(value: PopoverPositionX);
+    /** Posição do popover no eixo Y. */
+    get positionY(): PopoverPositionY;
+    set positionY(value: PopoverPositionY);
+    /** Evento de gatilho popover */
+    get triggerEvent(): PopoverTriggerEvent;
+    set triggerEvent(value: PopoverTriggerEvent);
+    /** Estratégia de rolagem popover */
+    get scrollStrategy(): PopoverScrollStrategy;
+    set scrollStrategy(value: PopoverScrollStrategy);
+    /** Atrazo de entrada popover */
+    get enterDelay(): number;
+    set enterDelay(value: number);
+    /** Atraso de saída popover */
+    get leaveDelay(): number;
+    set leaveDelay(value: number);
+    /** Gatilho de sobreposição de popover */
+    get overlapTrigger(): boolean;
+    set overlapTrigger(value: boolean);
+    /** Deslocamento alvo do popover x */
+    get targetOffsetX(): number;
+    set targetOffsetX(value: number);
+    /** Deslocamento do alvo popover y */
+    get targetOffsetY(): number;
+    set targetOffsetY(value: number);
+    /** Deslocamento da seta popover x */
+    get arrowOffsetX(): number;
+    set arrowOffsetX(value: number);
+    /** Largura da seta popover */
+    get arrowWidth(): number;
+    set arrowWidth(value: number);
+    /** Cor da seta popover */
+    get arrowColor(): string;
+    set arrowColor(value: string);
+    /**
+     * Contêiner popover fechado ao clicar
+     * default: true
+     */
+    get closeOnClick(): boolean;
+    set closeOnClick(value: boolean);
+    /**
+     * Desativar animações de popover e todos os elementos filhos
+     * default: false
+     */
+    get disableAnimation(): boolean;
+    set disableAnimation(value: boolean);
+    /**
+     * Armadilha de foco popover usando cdkTrapFocus
+     * default: true
+     */
+    get focusTrapEnabled(): boolean;
+    set focusTrapEnabled(value: boolean);
+    /**
+     * Captura automática da armadilha de foco popover usando cdkTrapFocusAutoCapture
+     * default: true
+     */
+    get focusTrapAutoCaptureEnabled(): boolean;
+    set focusTrapAutoCaptureEnabled(value: boolean);
+    /**
+     * Esse método usa classes definidas no elemento popover do host e as aplica no modelo popover
+     * exibido no contêiner de sobreposição. Caso contrário, é difícil estilizar o popover de fora do componente.
+     * @param classes list of class names
+     */
+    set panelClass(classes: string);
+    /** Evento emitido quando o popover é fechado. */
+    close: EventEmitter<void>;
+    templateRef: TemplateRef<any>;
+    constructor(_elementRef: ElementRef, zone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Manipule um evento de teclado do popover, delegando para a ação apropriada. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Isso emite um evento de fechamento no qual o acionador está inscrito. Quando emitido, o gatilho fechará o popover. */
+    _emitCloseEvent(): void;
+    /** Fechar popover ao clicar se closeOnClick for true */
+    onClick(): void;
+    /** Desativa o fechamento do popover ao sair do elemento de gatilho e passar o mouse sobre o popover */
+    onMouseOver(): void;
+    /** Habilita o fechamento do popover quando o mouse sai do elemento popover */
+    onMouseLeave(): void;
+    /** Define os estilos atuais para o popover para permitir a alteração dinâmica das configurações */
+    setCurrentStyles(): void;
+    /**
+     * É necessário definir classes baseadas em posição para garantir que a animação do painel popover
+     * se expanda na direção correta.
+     */
+    setPositionClasses(posX?: PopoverPositionX, posY?: PopoverPositionY): void;
+}

package/shared/gipi-components/popover/shared/popover-animations.d.ts

@@ -0,0 +1,13 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+/**
+ * Abaixo estão todas as animações para o componente popover.
+ * A duração da animação e os valores de tempo são baseados no Angular Material.
+ */
+/**
+ * Esta animação controla a entrada e saída do painel popover da página.
+ *
+ * Quando o painel popover é adicionado ao DOM, ele é dimensionado e esmaecido em sua borda.
+ *
+ * Quando o painel popover é removido do DOM, ele simplesmente desaparece após um breve atraso para exibir a ondulação.
+ */
+export declare const transformPopover: AnimationTriggerMetadata;

package/shared/gipi-components/popover/shared/popover-errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lança uma exceção para o caso em que o gatilho popover não possui uma instância popover válida
+ */
+export declare function throwPopoverMissingError(): void;
+/**
+ * Lança uma exceção para o caso em que o valor popoverPositionX do popover não é válido.
+ * Em outras palavras, não corresponde a 'before' ou 'after'.
+ */
+export declare function throwPopoverInvalidPositionX(): void;
+/**
+ * Lança uma exceção para o caso em que o valor popoverPositionY do popover não é válido.
+ * Em outras palavras, não corresponde a 'above' ou 'below'.
+ */
+export declare function throwPopoverInvalidPositionY(): void;

package/shared/gipi-components/popover/shared/popover-interfaces.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, EventEmitter, NgZone, TemplateRef } from '@angular/core';
+import { PopoverPositionX, PopoverPositionY, PopoverScrollStrategy, PopoverTriggerEvent } from './popover-types';
+export interface PopoverPanel {
+    popoverWidth: string;
+    positionX: PopoverPositionX;
+    positionY: PopoverPositionY;
+    containerPositioning: boolean;
+    overlapTrigger: boolean;
+    triggerEvent: PopoverTriggerEvent;
+    scrollStrategy: PopoverScrollStrategy;
+    enterDelay: number;
+    leaveDelay: number;
+    targetOffsetX: number;
+    targetOffsetY: number;
+    arrowOffsetX: number;
+    arrowWidth: number;
+    arrowColor: string;
+    closeOnClick: boolean;
+    closeDisabled: boolean;
+    setCurrentStyles: () => void;
+    templateRef: TemplateRef<any>;
+    close: EventEmitter<void>;
+    zone: NgZone;
+    setPositionClasses: (x: PopoverPositionX, y: PopoverPositionY) => void;
+    _emitCloseEvent: () => void;
+}
+export interface PopoverConfig {
+    popoverWidth: string;
+    positionX: PopoverPositionX;
+    positionY: PopoverPositionY;
+    overlapTrigger: boolean;
+    triggerEvent: PopoverTriggerEvent;
+    triggerDelay: number;
+    targetOffsetX: number;
+    targetOffsetY: number;
+    arrowOffsetX: number;
+    arrowWidth: number;
+    arrowColor: string;
+    closeOnClick: boolean;
+}
+export interface Target {
+    _elementRef: ElementRef;
+}

package/shared/gipi-components/popover/shared/popover-target.d.ts

@@ -0,0 +1,5 @@
+import { ElementRef } from '@angular/core';
+export declare class GIPIPopoverTarget {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}

package/shared/gipi-components/popover/shared/popover-trigger.d.ts

@@ -0,0 +1,140 @@
+import { Direction, Directionality } from '@angular/cdk/bidi';
+import { Overlay } from '@angular/cdk/overlay';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { PopoverPanel, Target } from './popover-interfaces';
+import { PopoverPositionX, PopoverPositionY, PopoverTriggerEvent } from './popover-types';
+/**
+ * Esta diretiva destina-se a ser usada em conjunto com uma tag gipi-popover.
+ * Ele é responsável por alternar a exibição da instância popover fornecida.
+ */
+export declare class GIPIPopoverTrigger implements AfterViewInit, OnDestroy {
+    private _overlay;
+    _elementRef: ElementRef;
+    private _viewContainerRef;
+    private _dir;
+    private _changeDetectorRef;
+    ariaHaspopup: boolean;
+    popoverOpened: Subject<void>;
+    popoverClosed: Subject<void>;
+    private _portal;
+    private _overlayRef;
+    private _popoverOpen;
+    private _halt;
+    private _backdropSubscription;
+    private _positionSubscription;
+    private _detachmentsSubscription;
+    private _mouseoverTimer;
+    private _openedByMouse;
+    private _onDestroy;
+    /** References the popover instance that the trigger is associated with. */
+    popover: PopoverPanel;
+    /** References the popover target instance that the trigger is associated with. */
+    targetElement: Target;
+    /** Position of the popover in the X axis */
+    positionX: PopoverPositionX;
+    /** Position of the popover in the Y axis */
+    positionY: PopoverPositionY;
+    /** Popover trigger event */
+    triggerEvent: PopoverTriggerEvent;
+    /** Popover delay */
+    enterDelay: number;
+    /** Popover delay */
+    leaveDelay: number;
+    /** Popover overlap trigger */
+    overlapTrigger: boolean;
+    /** Popover target offset x */
+    targetOffsetX: number;
+    /** Popover target offset y */
+    targetOffsetY: number;
+    /** Popover arrow offset x */
+    arrowOffsetX: number;
+    /** Popover arrow width */
+    arrowWidth: number;
+    /** Popover arrow color */
+    arrowColor: string;
+    /** Popover container close on click */
+    closeOnClick: boolean;
+    /** Popover backdrop close on click */
+    backdropCloseOnClick: boolean;
+    /** Event emitted when the associated popover is opened. */
+    opened: EventEmitter<void>;
+    /** Event emitted when the associated popover is closed. */
+    closed: EventEmitter<void>;
+    constructor(_overlay: Overlay, _elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _dir: Directionality, _changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _setCurrentConfig;
+    /** Whether the popover is open. */
+    get popoverOpen(): boolean;
+    onClick(event: MouseEvent): void;
+    onMouseEnter(event: MouseEvent): void;
+    onMouseLeave(event: MouseEvent): void;
+    /** Toggles the popover between the open and closed states. */
+    togglePopover(): void;
+    /** Opens the popover. */
+    openPopover(): void;
+    /** Closes the popover. */
+    closePopover(): void;
+    /** Removes the popover from the DOM. */
+    destroyPopover(): void;
+    /** Focuses the popover trigger. */
+    focus(): void;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    /**
+    * This method ensures that the popover closes when the overlay backdrop is clicked.
+    * We do not use first() here because doing so would not catch clicks from within
+    * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe
+    * explicitly when the popover is closed or destroyed.
+    */
+    private _subscribeToBackdrop;
+    private _subscribeToDetachments;
+    /**
+    * This method sets the popover state to open and focuses the first item if
+    * the popover was opened via the keyboard.
+    */
+    private _initPopover;
+    /**
+    * This method resets the popover when it's closed, most importantly restoring
+    * focus to the popover trigger if the popover was opened via the keyboard.
+    */
+    private _resetPopover;
+    /** set state rather than toggle to support triggers sharing a popover */
+    private _setPopoverOpened;
+    /** set state rather than toggle to support triggers sharing a popover */
+    private _setPopoverClosed;
+    /**
+    *  This method checks that a valid instance of MdPopover has been passed into
+    *  mdPopoverTriggerFor. If not, an exception is thrown.
+    */
+    private _checkPopover;
+    /**
+    *  This method creates the overlay from the provided popover's template and saves its
+    *  OverlayRef so that it can be attached to the DOM when openPopover is called.
+    */
+    private _createOverlay;
+    /**
+    * This method builds the configuration object needed to create the overlay, the OverlayConfig.
+    * @returns OverlayConfig
+    */
+    private _getOverlayConfig;
+    /**
+     * This method returns the scroll strategy used by the cdk/overlay.
+     */
+    private _getOverlayScrollStrategy;
+    /**
+    * Listens to changes in the position of the overlay and sets the correct classes
+    * on the popover based on the new position. This ensures the animation origin is always
+    * correct, even if a fallback position is used for the overlay.
+    */
+    private _subscribeToPositions;
+    /**
+    * This method builds the position strategy for the overlay, so the popover is properly connected
+    * to the trigger.
+    * @returns ConnectedPositionStrategy
+    */
+    private _getPosition;
+    private _cleanUpSubscriptions;
+    _handleMousedown(event: MouseEvent): void;
+}

package/shared/gipi-components/popover/shared/popover-types.d.ts

@@ -0,0 +1,4 @@
+export declare type PopoverPositionX = 'before' | 'after';
+export declare type PopoverPositionY = 'above' | 'below';
+export declare type PopoverTriggerEvent = 'click' | 'hover' | 'none';
+export declare type PopoverScrollStrategy = 'noop' | 'close' | 'block' | 'reposition';

package/shared/gipi-components/radio-group/radio-group.component.d.ts

@@ -0,0 +1,33 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatRadioChange } from '@angular/material';
+export declare class GIPIRadioGroupComponent implements ControlValueAccessor, OnInit {
+    private _changeDetectorRef;
+    private _name;
+    _enumList: any[];
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    disabled: boolean;
+    required: boolean;
+    fieldset: boolean;
+    direction: 'row' | 'column';
+    enum: any;
+    sort: (a: any, b: any) => number;
+    valuesExclud: string[];
+    valuesOmit: string[];
+    val: any;
+    get value(): any;
+    set value(val: any);
+    selectionChange: EventEmitter<string>;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): 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;
+}

package/shared/gipi-components/range-page/range-page.component.d.ts

@@ -0,0 +1,55 @@
+import { ChangeDetectorRef, ElementRef, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class RangePage {
+    start: number;
+    end: number;
+    getTotalCount(): number;
+    getRange(): number[];
+    constructor(start?: number, end?: number);
+}
+export declare class GIPIRangePageComponent implements OnInit, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    private _name;
+    _startPage: number;
+    _endPage: number;
+    id: string;
+    name: string;
+    label: string;
+    tooltip: string;
+    placeholderStart: string;
+    placeholderEnd: string;
+    help: string;
+    private _min;
+    get min(): number;
+    set min(value: number);
+    private _max;
+    get max(): number;
+    set max(value: number);
+    private _step;
+    get step(): number;
+    set step(value: number);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    onChange: Function;
+    onTouched: Function;
+    get formattedValue(): string;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: RangePage): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private _initPage;
+    updateEndPage(): void;
+    updateStartPage(): void;
+    previous(): void;
+    next(): void;
+    selectText(input: HTMLInputElement): void;
+    private _propagateChange;
+}

package/shared/gipi-components/range-slider/range-slider.component.d.ts

@@ -0,0 +1,57 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export interface RangeSlider {
+    from: number;
+    to: number;
+}
+export declare class GIPIRangeSliderComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    fromSlider: ElementRef;
+    toSlider: ElementRef;
+    private _name;
+    id: string;
+    name: string;
+    label: string;
+    help: string;
+    min: number;
+    max: number;
+    private _maxRange;
+    get maxRange(): number;
+    set maxRange(value: number);
+    private _fromValue;
+    get fromValue(): number;
+    set fromValue(value: number);
+    private _toValue;
+    get toValue(): number;
+    set toValue(value: number);
+    private _step;
+    get step(): number;
+    set step(value: number);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    onChange: Function;
+    onTouched: Function;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: RangeSlider): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    controlFromInput(isByNgModel: boolean): void;
+    controlToInput(isByNgModel: boolean): void;
+    controlFromSlider(): void;
+    controlToSlider(): void;
+    private _getParsed;
+    private _fillSlider;
+    private _setToggleAccessible;
+    private _roundToStep;
+    private _notifyValueChange;
+    onBlur(): void;
+}

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

@@ -0,0 +1,45 @@
+import { EventEmitter, OnInit, TrackByFunction } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class GIPISelectComponent<T> implements OnInit, ControlValueAccessor {
+    _overlayVisible: boolean;
+    _modelValue: T;
+    id: string;
+    name: string;
+    ariaLabel: string;
+    label: string;
+    placeholder: string;
+    disabled: boolean;
+    required: boolean;
+    iconPrefix: string;
+    iconPrefixWidth: string | number;
+    iconPrefixHeight: string | number;
+    svgIconPrefix: string;
+    iconSuffix: string;
+    iconSuffixWidth: string | number;
+    iconSuffixHeight: string | number;
+    svgIconSuffix: string;
+    property: string;
+    propertyFn: (obj: T) => string;
+    options: T[];
+    trackyBy: string;
+    set model(model: any);
+    get model(): any;
+    onClick: EventEmitter<MouseEvent>;
+    onShowOverlay: EventEmitter<void>;
+    onModelChange: EventEmitter<T>;
+    onSelectionChange: EventEmitter<T>;
+    get optionSelectedText(): string;
+    trackByOption: TrackByFunction<T>;
+    constructor();
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    toggleOverlay(): void;
+    getPropertyValue(entity: T): string;
+    private _getValue;
+    isOptionActive(option: T): boolean;
+    onClickOption(option: T): void;
+}

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

@@ -0,0 +1,39 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class GIPISelectButtonComponent implements ControlValueAccessor, OnInit {
+    private _elementRef;
+    private _changeDetectorRef;
+    readonly isButtonPrimary: boolean;
+    readonly isButtonSecondary: boolean;
+    id: string | number;
+    arialLabel: string;
+    dataKey: string;
+    label: string;
+    required: boolean;
+    options: any[];
+    optionLabel: string;
+    optionValue: string;
+    optionDisabled: string;
+    multiple: boolean;
+    disabled: boolean;
+    onOptionClick: EventEmitter<any>;
+    onChange: EventEmitter<any>;
+    value: any;
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    getOptionLabel(option: any): any;
+    getOptionValue(option: any): any;
+    isOptionDisabled(option: any): any;
+    onItemClick(event: any, option: any, index: number): void;
+    isSelected(option: any): boolean;
+    removeOption(option: any): void;
+    onBlur(): void;
+    private _getHostElement;
+    private _hasHostAttributes;
+}

package/shared/gipi-components/sidebar/container/container.component.d.ts

@@ -0,0 +1,15 @@
+import { AfterContentInit, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BreakpointObserverService } from '../../../../core/services/breakpoint-observer.service';
+import { NavService } from '../../../../core/services/nav.service';
+export declare class GIPISidenavContainerComponent implements OnInit, AfterContentInit {
+    private _navService;
+    private _breakpointObserverService;
+    constructor(_navService: NavService, _breakpointObserverService: BreakpointObserverService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    get isOpened(): Observable<boolean>;
+    get isScreenLarge(): Observable<boolean>;
+    onClickBackdrop(): void;
+    onResize(event: UIEvent): void;
+}

package/shared/gipi-components/sidebar/sidenav/sidenav.component.d.ts

@@ -0,0 +1,40 @@
+import { AfterViewInit, EventEmitter, OnInit } from '@angular/core';
+import { MatSidenav } from '@angular/material/sidenav';
+import { Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { MenuDTO } from '../../../../core/models/dto/menu.dto';
+import { BreakpointObserverService } from '../../../../core/services/breakpoint-observer.service';
+import { NavService } from '../../../../core/services/nav.service';
+export declare class GIPISidenavComponent implements OnInit, AfterViewInit {
+    private _navService;
+    private _breakpointObserverService;
+    private _router;
+    sidenav: MatSidenav;
+    _levelOneMenuCollapsableSelected: MenuDTO;
+    _levelTwoMenuCollapsableSelected: MenuDTO;
+    _mouseEnter: boolean;
+    menuItems: MenuDTO[];
+    labelToggle: string;
+    iconConfiguration: string;
+    svgIconConfiguration: string;
+    labelConfiguration: string;
+    showConfiguration: boolean;
+    onClickMenuItem: EventEmitter<MenuDTO | null>;
+    constructor(_navService: NavService, _breakpointObserverService: BreakpointObserverService, _router: Router);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    get isOpened(): Observable<boolean>;
+    get isScreenLarge(): Observable<boolean>;
+    get submenuBackButtonName(): Observable<string>;
+    get levelMenuCollapsableSelected(): Observable<MenuDTO[]>;
+    toggleSidenav(): void;
+    onMenuCollapsableSelected(menu: MenuDTO): void;
+    onMenuCollapsableReset(menuList: MenuDTO[]): void;
+    onMenuCollapsableGoBack(): void;
+    isMenuActive(menu: MenuDTO): boolean;
+    isMenuCollapsableActive(menu: MenuDTO): boolean;
+    onMenuItemSelected(menu?: MenuDTO, closeNav?: boolean): void;
+    getMenuName(name: string): string;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+}