@gipisistemas/ng-core 1.1.0 → 1.1.1

package/core/app-messages.d.ts

@@ -0,0 +1,9 @@
+export interface AppMessages {
+    SUCCESS: string;
+    RETURN_CONFIRMATION: string;
+    DELETE_CONFIRMATION: string;
+    DELETE_ALL_CONFIRMATION: string;
+    BUTTON_OK_CONFIRMATION: string;
+    BUTTON_CANCEL_CONFIRMATION: string;
+    NOT_PERMISSION: string;
+}

package/core/app.messages.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { AppMessages } from './app-messages';
+export declare const APP_MESSAGES: InjectionToken<AppMessages>;
+export declare const DEFAULT_MESSAGES: AppMessages;

package/core/components/abstract-crud.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AbstractModel } from '../models/abstract.model';
+import { FilterDTO } from '../models/dto/filter.dto';
+import { AbstractCrudService } from '../services/abstract-crud.service';
+import { ConfirmationService } from '../services/confirmation.service';
+import { MessageService } from '../services/message.service';
+import { AbstractFindComponent } from './abstract-find.component';
+export declare abstract class AbstractCrudComponent<T extends AbstractModel, F extends FilterDTO> extends AbstractFindComponent<T, F> implements OnInit {
+    protected service: AbstractCrudService<T, F>;
+    protected messageService: MessageService;
+    protected confirmationService: ConfirmationService;
+    protected router: Router;
+    protected activatedRoute: ActivatedRoute;
+    entityValue: T;
+    entityChange: EventEmitter<T>;
+    get entity(): T;
+    set entity(entity: T);
+    constructor(service: AbstractCrudService<T, F>, messageService: MessageService, confirmationService: ConfirmationService, router: Router, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    save(edit?: boolean, filter?: boolean): void;
+    preSave(): void;
+    return(): void;
+    protected abstract newEntity(): T;
+    protected initializeForm(): void;
+    afterInitializeForm(): void;
+}

package/core/components/abstract-find.component.d.ts

@@ -0,0 +1,43 @@
+import { OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AbstractModel } from '../models/abstract.model';
+import { FilterDTO } from '../models/dto/filter.dto';
+import { PageDTO } from '../models/dto/page.dto';
+import { SortDTO } from '../models/dto/sort.dto';
+import { TableColumnDTO } from '../models/dto/table-column.dto';
+import { TablePageEventDTO } from '../models/dto/table-page-event.dto';
+import { AbstractCrudService } from '../services/abstract-crud.service';
+import { ConfirmationService } from '../services/confirmation.service';
+import { MessageService } from '../services/message.service';
+import { AbstractComponent } from './abstract.component';
+export declare abstract class AbstractFindComponent<T extends AbstractModel, F extends FilterDTO> extends AbstractComponent implements OnInit {
+    protected service: AbstractCrudService<T, F>;
+    protected messageService: MessageService;
+    protected confirmationService: ConfirmationService;
+    protected router: Router;
+    protected activatedRoute: ActivatedRoute;
+    filter: F;
+    page: PageDTO<T>;
+    columns: TableColumnDTO[];
+    tablePageEventDTO: TablePageEventDTO;
+    constructor(service: AbstractCrudService<T, F>, messageService: MessageService, confirmationService: ConfirmationService, router: Router, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    new(): void;
+    edit(entity: T): void;
+    view(entity: T): void;
+    delete(entity: T, filter?: boolean): void;
+    deleteAll(entityList: T[], filter?: boolean): void;
+    updateStatus(entity: T, enabled: boolean): void;
+    preDelete(): void;
+    clear(): void;
+    protected getPath(): string;
+    protected newPage(): PageDTO<T>;
+    protected newFilterDTO(): F;
+    protected getFilterDTOSessionStorage(): Promise<void>;
+    protected createTableColumns(): TableColumnDTO[];
+    protected createSorts(): SortDTO[];
+    find(pageEvent?: any): void;
+    isFinding(): boolean;
+    isViewing(): boolean;
+    isCreating(): boolean;
+}

package/core/components/abstract.component.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { MessageService } from '../services/message.service';
+export declare abstract class AbstractComponent implements OnInit, OnDestroy {
+    protected messageService: MessageService;
+    protected router: Router;
+    protected activatedRoute: ActivatedRoute;
+    loading: boolean;
+    loadingChange: EventEmitter<boolean>;
+    constructor(messageService: MessageService, router: Router, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    hasPermission(permission: string): boolean;
+    protected handleError(error: any): void;
+    protected addSuccessMessage(message: string): void;
+    protected addErrorMessage(message: string): void;
+    protected addWarningMessage(message: string): void;
+    protected addInfoMessage(message: string): void;
+    download(data: any, fileName: string, mimeType: string): void;
+    downloadContent(response: any): void;
+    printArchive(data: any, mimeType: string): void;
+    UUIDIsValid(id: number | string): boolean;
+}

package/core/components/alert/alert.component.d.ts

@@ -0,0 +1,7 @@
+import { OnInit } from '@angular/core';
+import { MessageDTO } from '../../models/dto/message.dto';
+export declare class AlertComponent implements OnInit {
+    message: MessageDTO;
+    constructor(message: MessageDTO);
+    ngOnInit(): void;
+}

package/core/core.module.d.ts

@@ -0,0 +1,17 @@
+import { ModuleWithProviders } from '@angular/core';
+import { AppMessages } from './app-messages';
+export declare const customCurrencyMaskConfig: {
+    align: string;
+    allowNegative: boolean;
+    allowZero: boolean;
+    decimal: string;
+    precision: number;
+    prefix: string;
+    suffix: string;
+    thousands: string;
+    nullable: boolean;
+    max: number;
+};
+export declare class CoreModule {
+    static setMessages(messages: AppMessages): ModuleWithProviders<CoreModule>;
+}

package/core/custom-breakpoints.d.ts

@@ -0,0 +1,7 @@
+import { BreakPoint } from '@angular/flex-layout';
+export declare const GIPI_BREAKPOINTS: BreakPoint[];
+export declare const GIPI_CUSTOM_BREAKPOINTS_PROVIDER: {
+    provide: import("@angular/core").InjectionToken<BreakPoint | BreakPoint[]>;
+    useValue: BreakPoint[];
+    multi: boolean;
+};

package/core/enums/local-time.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum LocalTimeEnum {
+    FULL = "FULL",
+    SHORT = "SHORT"
+}
+export declare type LocalTimeType = 'FULL' | 'SHORT';

package/core/extensions/string.extension.d.ts

@@ -0,0 +1,3 @@
+interface String {
+    numberFullName(this: string, isCurrency?: boolean): string;
+}

package/core/gipi-components/components/abstract-crud.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { GIPIAbstractModel } from '../models/abstract.model';
+import { GIPIAbstractCrudService } from '../services/abstract-crud.service';
+import { GIPIBaseService } from '../services/base.service';
+import { GIPIAbstractComponent } from './abstract.component';
+export declare abstract class GIPIAbstractCrudComponent<TEntity extends GIPIAbstractModel> extends GIPIAbstractComponent implements OnInit, AfterViewInit, OnDestroy {
+    protected abstractCrudService: GIPIAbstractCrudService<TEntity, any>;
+    protected baseService: GIPIBaseService;
+    protected activatedRoute: ActivatedRoute;
+    private _entity;
+    set entity(value: TEntity);
+    get entity(): TEntity;
+    constructor(abstractCrudService: GIPIAbstractCrudService<TEntity, any>, baseService: GIPIBaseService, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected onInitForm(): void;
+    protected abstract newEntity(): TEntity;
+    protected abstract isValid(entity: TEntity): boolean;
+    protected onAfterGetOne(): void;
+    protected preSave(entity: TEntity): void;
+    save(entity?: TEntity, toGoBack?: boolean): void;
+    goBack(showConfirmation?: boolean): void;
+}

package/core/gipi-components/components/abstract-find.component.d.ts

@@ -0,0 +1,73 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { TableColumnDTO } from '../../models/dto/table-column.dto';
+import { TablePageEventDTO } from '../../models/dto/table-page-event.dto';
+import { GIPIAbstractFilterModel } from '../models/abstract-filter.model';
+import { GIPIAbstractModel } from '../models/abstract.model';
+import { GIPIAppliedFilter } from '../models/applied-filter.model';
+import { GIPIPageModel } from '../models/page.model';
+import { GIPISortModel } from '../models/sort.model';
+import { GIPIAbstractCrudService } from '../services/abstract-crud.service';
+import { GIPIBaseService } from '../services/base.service';
+import { GIPIUuid } from '../types/uuid.type';
+import { GIPIAbstractComponent } from './abstract.component';
+export declare abstract class GIPIAbstractFindComponent<TEntity extends GIPIAbstractModel, TFilter extends GIPIAbstractFilterModel> extends GIPIAbstractComponent implements OnInit, AfterViewInit, OnDestroy {
+    protected abstractCrudService: GIPIAbstractCrudService<TEntity, TFilter>;
+    protected baseService: GIPIBaseService;
+    protected activatedRoute: ActivatedRoute;
+    private _filter;
+    set filter(value: TFilter);
+    get filter(): TFilter;
+    private _page;
+    set page(value: GIPIPageModel<TEntity>);
+    get page(): GIPIPageModel<TEntity>;
+    private _tablePageEventDTO;
+    set tablePageEventDTO(value: TablePageEventDTO);
+    get tablePageEventDTO(): TablePageEventDTO;
+    private _columns;
+    set columns(value: TableColumnDTO[]);
+    get columns(): TableColumnDTO[];
+    private _appliedFilters;
+    set appliedFilters(value: GIPIAppliedFilter<any>[]);
+    get appliedFilters(): GIPIAppliedFilter<any>[];
+    constructor(abstractCrudService: GIPIAbstractCrudService<TEntity, TFilter>, baseService: GIPIBaseService, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected abstract newFilter(): TFilter;
+    protected abstract createTableColumns(): TableColumnDTO[];
+    protected abstract setAppliedFilters(): void;
+    protected abstract clearAppliedFilters(): void;
+    abstract removeAppliedFilters(filter: {
+        chip: GIPIAppliedFilter<any>;
+        index: number;
+    }): void;
+    protected abstract setFilterSessionStorage(): void;
+    protected abstract handleFilterSessionStorage(): void;
+    protected newPage(): GIPIPageModel<TEntity>;
+    protected createTableSorts(): GIPISortModel[];
+    protected preDelete(id?: GIPIUuid): void;
+    protected existInAppliedFilters<T = any>(key: T): boolean;
+    /** @Internal */
+    protected _onInitFilter(): void;
+    findAll(pageEvent?: any): void;
+    newRegister(permission?: string): void;
+    editRegister(id?: GIPIUuid, permission?: string): void;
+    deleteRegister(id?: GIPIUuid, permission?: string, fetchAgain?: boolean): void;
+    /** @Internal */
+    private _deleteRegister;
+    deleteAllRegister(idList?: GIPIUuid[], permission?: string, fetchAgain?: boolean): void;
+    /** @Internal */
+    private _deleteAllRegister;
+    viewRegister(id?: GIPIUuid, permission?: string): void;
+    editOrViewRegister(id: GIPIUuid, permission: string): void;
+    enableOrDisableRegister(action: 'DISABLE' | 'ENABLE', id?: GIPIUuid, permission?: string, fetchAgain?: boolean): void;
+    /** @Internal */
+    private _enableOrDisableRegister;
+    enableAndDisableAllRegister(action: 'DISABLE' | 'ENABLE', idList?: GIPIUuid[], permission?: string, fetchAgain?: boolean): void;
+    /** @Internal */
+    private _enableAndDisableAllRegister;
+    clear(): void;
+    handleEntityId(id: GIPIUuid): GIPIUuid;
+    handleEntityIdList(idList: GIPIUuid[]): GIPIUuid[];
+}

package/core/gipi-components/components/abstract.component.d.ts

@@ -0,0 +1,38 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { MessageDTO } from '../../models/dto/message.dto';
+import { GIPIBasePermission } from '../interface/base-permission.interface';
+import { GIPIBaseService } from '../services/base.service';
+import { GIPIUuid } from '../types/uuid.type';
+export declare abstract class GIPIAbstractComponent implements OnInit, AfterViewInit, OnDestroy {
+    protected baseService: GIPIBaseService;
+    protected activatedRoute: ActivatedRoute;
+    private _loading;
+    set loading(value: boolean);
+    get loading(): boolean;
+    private _basePermissionList;
+    set basePermissionList(value: GIPIBasePermission);
+    get basePermissionList(): GIPIBasePermission;
+    constructor(baseService: GIPIBaseService, activatedRoute: ActivatedRoute);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isCreating(): boolean;
+    isEditing(): boolean;
+    isViewing(): boolean;
+    isListing(): boolean;
+    hasPermission(permission: string): boolean;
+    UUIDIsValid(id: GIPIUuid): boolean;
+    protected onInitForm(): void;
+    protected onAfterInitForm(): void;
+    protected onDestroy(): void;
+    protected getPath(): string;
+    protected navigateByUrl(navigateByUrl: string, navigate: any[], skipLocationChange?: boolean): void;
+    protected addMessage(message: MessageDTO): void;
+    protected addSuccessMessage(message: string): void;
+    protected addErrorMessage(message: string): void;
+    protected addWarningMessage(message: string): void;
+    protected addInfoMessage(message: string): void;
+    protected handleError(error: any): void;
+    getExistInRouterPath(value: string, validateParams?: boolean): boolean;
+}

package/core/gipi-components/decorators/autowired.decorator.d.ts

@@ -0,0 +1,7 @@
+export declare type GIPIKey = string | symbol;
+export declare type ClassRef<T = any> = new (...args: any[]) => T;
+export declare const ƟPROV: 'ɵprov';
+export declare const ƟFAC: 'ɵfac';
+export declare const ƟCMP: 'ɵcmp';
+export declare function getReflectType<T = any>(target: Object, propertyKey: string | symbol): ClassRef<T>;
+export declare function GIPIAutowired(): PropertyDecorator;

package/core/gipi-components/enums/sort-direction.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum GIPISortDirectionEnum {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare type GIPISortDirection = 'ASC' | 'DESC';

package/core/gipi-components/interface/abstract-crud.interface.d.ts

@@ -0,0 +1,5 @@
+import { GIPIGenericType } from '../types/generic.type';
+export interface GIPIAbstractCrudInterface<TEntity = void> {
+    save<T = void>(entity: GIPIGenericType<T, TEntity>, toGoBack?: boolean): void;
+    goBack(showConfirmation?: boolean): void;
+}

package/core/gipi-components/interface/abstract-find.interface.d.ts

@@ -0,0 +1,12 @@
+import { GIPIAbstractFilterModel } from '../models/abstract-filter.model';
+import { GIPIAbstractModel } from '../models/abstract.model';
+import { GIPIUuid } from '../types/uuid.type';
+export interface GIPIAbstractFindInterface<TEntity extends GIPIAbstractModel, TFilter extends GIPIAbstractFilterModel> {
+    clear(): void;
+    findAll(pageEvent?: any): void;
+    newRegister(permission: string): void;
+    editRegister(id: GIPIUuid, permission: string): void;
+    deleteRegister(id: GIPIUuid, permission: string, fetchAgain?: boolean): void;
+    viewRegister(id: GIPIUuid, permission: string): void;
+    editOrViewRegister(id: GIPIUuid, permission: string): void;
+}

package/core/gipi-components/interface/abstract.interface.d.ts

@@ -0,0 +1,11 @@
+export interface GIPIAbstractInterface {
+    onInitForm(): void;
+    onAfterInitForm(): void;
+    onDestroy(): void;
+    getPath(): string;
+    navigateByUrl(navigateByUrl: string, navigate: any[], skipLocationChange?: boolean): void;
+    isCreating(): boolean;
+    isEditing(): boolean;
+    isViewing(): boolean;
+    isListing(): boolean;
+}

package/core/gipi-components/interface/base-permission.interface.d.ts

@@ -0,0 +1,9 @@
+export interface GIPIBasePermission {
+    MAKE: string;
+    UPDATE: string;
+    READ: string;
+    DELETE: string;
+    ENABLE_DISABLE: string;
+    REPORT_EXPORT?: string;
+    REPORT_READ?: string;
+}

package/core/gipi-components/models/abstract-filter.model.d.ts

@@ -0,0 +1,9 @@
+import { GIPISortModel } from './sort.model';
+export declare class GIPIAbstractFilterModel {
+    sorts: GIPISortModel[];
+    pageNumber: number;
+    pageSize: number;
+    offset: number;
+    /** @Transient */
+    originScreen: string;
+}

package/core/gipi-components/models/abstract.model.d.ts

@@ -0,0 +1,7 @@
+import { GIPIUuid } from '../types/uuid.type';
+export declare abstract class GIPIAbstractModel {
+    id: GIPIUuid;
+    enabled: boolean;
+    /** @Transient */
+    selected: boolean;
+}

package/core/gipi-components/models/applied-filter.model.d.ts

@@ -0,0 +1,9 @@
+export declare class GIPIAppliedFilter<T = any> {
+    private _description;
+    private _key;
+    constructor(description: string, key: T);
+    set description(description: string);
+    get description(): string;
+    set key(key: T);
+    get key(): T;
+}

package/core/gipi-components/models/dto/abstract.dto.d.ts

@@ -0,0 +1,7 @@
+import { GIPIUuid } from '../../types/uuid.type';
+export declare abstract class GIPIAbstractDTO {
+    id: GIPIUuid;
+    enabled: boolean;
+    /** @Transient */
+    selected: boolean;
+}

package/core/gipi-components/models/page-event.model.d.ts

@@ -0,0 +1,18 @@
+export declare class GIPIPageEvent {
+    /** The current page index. */
+    private _pageIndex;
+    /** The current page size */
+    private _pageSize;
+    /** The current total number of items being paged */
+    private _length;
+    constructor(pageIndex?: number, pageSize?: number, length?: number);
+    /** O índice da página atual. */
+    get pageIndex(): number;
+    set pageIndex(value: number);
+    /** O tamanho da página atual */
+    get pageSize(): number;
+    set pageSize(value: number);
+    /** O número total atual de itens sendo paginados */
+    get length(): number;
+    set length(value: number);
+}

package/core/gipi-components/models/page.model.d.ts

@@ -0,0 +1,7 @@
+export declare class GIPIPageModel<TEntity> {
+    content: TEntity[];
+    number: number;
+    totalElements: number;
+    totalPages: number;
+    constructor();
+}

package/core/gipi-components/models/sort.model.d.ts

@@ -0,0 +1,6 @@
+import { GIPISortDirection, GIPISortDirectionEnum } from '../enums/sort-direction.enum';
+export declare class GIPISortModel {
+    direction: GIPISortDirectionEnum | GIPISortDirection;
+    field: string;
+    constructor(field: string, direction: GIPISortDirectionEnum | GIPISortDirection);
+}

package/core/gipi-components/services/abstract-crud.service.d.ts

@@ -0,0 +1,83 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { GIPIAbstractFilterModel } from '../models/abstract-filter.model';
+import { GIPIAbstractModel } from '../models/abstract.model';
+import { GIPIPageModel } from '../models/page.model';
+import { GIPISortModel } from '../models/sort.model';
+import { GIPIUuid } from '../types/uuid.type';
+import { GIPIAbstractService } from './abstract.service';
+import { GIPIBaseService } from './base.service';
+export declare abstract class GIPIAbstractCrudService<TEntity extends GIPIAbstractModel, TFilter extends GIPIAbstractFilterModel> extends GIPIAbstractService implements OnDestroy {
+    protected path: string;
+    protected version: string;
+    protected baseService: GIPIBaseService;
+    constructor(path: string, version: string, baseService: GIPIBaseService);
+    ngOnDestroy(): void;
+    /**
+     * Refers to the save endpoint
+     * @type POST
+     * @path resource/version
+     */
+    save<T = any>(entity: T, version?: string): Observable<T>;
+    /**
+     * Refers to the save-all endpoint
+     * @type POST
+     * @path resource/version/save-all
+     */
+    saveAll<T = any>(entities: T[], version?: string): Observable<T[]>;
+    /**
+     * Refers to the delete endpoint
+     * @type DELETE
+     * @path resource/version/{id}
+     */
+    delete<T = any>(id: number | string, version?: string): Observable<T>;
+    /**
+     * Refers to the delete-all endpoint
+     * @type POST
+     * @path resource/version/delete-all
+     */
+    deleteAll(idList: GIPIUuid[], version?: string): Observable<boolean>;
+    /**
+     * Refers to the get-one endpoint
+     * @type GET
+     * @path resource/version/{id}
+     */
+    getOne<T = any>(id: GIPIUuid, version?: string): Observable<T>;
+    /**
+     * Refers to the find-all endpoint without the filters
+     * @type GET
+     * @path resource/version
+     */
+    find<T = any>(version?: string): Observable<GIPIPageModel<T>>;
+    /**
+     * Refers to the find-all endpoint with filters
+     * @type POST
+     * @path resource/version/find-all
+     */
+    findAll<F extends GIPIAbstractFilterModel = any, T = any>(filter?: F, version?: string): Observable<GIPIPageModel<T>>;
+    /**
+     * Refers to the find-all-enabled endpoint
+     * @type GET
+     * @path resource/version/find-all-enabled
+     */
+    findAllEnabled<T = any>(page: number, size: number, version?: string): Observable<GIPIPageModel<T>>;
+    /**
+     * Refers to the find-by-value endpoint
+     * @type GET
+     * @path resource/version/find-by-value
+     */
+    findByValue<T = any>(value: string, page: number, size?: number, sort?: GIPISortModel, version?: string): Observable<GIPIPageModel<T>>;
+    /**
+     * Refers to the enable-or-disable endpoint
+     * @type PATCH
+     * @path resource/version/enable-or-disable/{id}/{action}
+     */
+    enableOrDisable(id: GIPIUuid, action: 'DISABLE' | 'ENABLE', version?: string): Observable<boolean>;
+    /**
+     * Refers to the enable-or-disable-all endpoint
+     * @type PATCH
+     * @path resource/version/enable-or-disable-all/{action}
+     */
+    enableOrDisableAll(idList: GIPIUuid[], action: 'DISABLE' | 'ENABLE', version?: string): Observable<boolean>;
+    validate<T = any>(entity: T): string;
+}

package/core/gipi-components/services/abstract.service.d.ts

@@ -0,0 +1,19 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+export declare class GIPIAbstractService implements OnDestroy {
+    protected path: string;
+    protected version: string;
+    protected handleDestroy: Subject<void>;
+    constructor(path: string, version: string);
+    ngOnDestroy(): void;
+    protected url(resource?: string, version?: string): string;
+    protected options(params?: HttpParams, headers?: HttpHeaders): {
+        headers: HttpHeaders;
+        params: HttpParams;
+    };
+    protected buildHeaders(): HttpHeaders;
+    protected buildParams(): HttpParams;
+    protected handleMapper<T = void>(jsonObj: Object): (T extends void ? any : T);
+    protected handleError<T = void>(error: string): Observable<(T extends void ? any : T)>;
+}

package/core/gipi-components/services/base.service.d.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from '@angular/common/http';
+import { ChangeDetectorRef, Injector, OnDestroy } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Router } from '@angular/router';
+import { ConfirmationService } from '../../services/confirmation.service';
+import { DialogService } from '../../services/dialog.service';
+import { MessageService } from '../../services/message.service';
+import { GIPIFileService } from './file.service';
+import { GIPISessionStorageService } from './session-storage.service';
+export declare class GIPIBaseService implements OnDestroy {
+    private _injector;
+    private _router;
+    private _sessionStorageService;
+    private _confirmationService;
+    private _messageService;
+    private _dialogService;
+    private _fileService;
+    private _matDialog;
+    private _httpClient;
+    private _changeDetectorRef;
+    private _matSnackBar;
+    constructor(_injector: Injector, _router: Router);
+    ngOnDestroy(): void;
+    get sessionStorageService(): GIPISessionStorageService;
+    get confirmationService(): ConfirmationService;
+    get messageService(): MessageService;
+    get dialogService(): DialogService;
+    get fileService(): GIPIFileService;
+    get matDialog(): MatDialog;
+    get httpClient(): HttpClient;
+    get router(): Router;
+    get changeDetectorRef(): ChangeDetectorRef;
+    get matSnackBar(): MatSnackBar;
+}

package/core/gipi-components/services/file.service.d.ts

@@ -0,0 +1,6 @@
+export declare class GIPIFileService {
+    constructor();
+    download(data: any, fileName: string, mimeType: string): void;
+    downloadContent(response: any): void;
+    printArchive(data: any, mimeType: string): void;
+}

package/core/gipi-components/services/session-storage.service.d.ts

@@ -0,0 +1,8 @@
+export declare class GIPISessionStorageService<TFilter = any> {
+    private _storage;
+    constructor();
+    set<T = any>(key: string, value: T): boolean;
+    get<T = any>(key: string): T;
+    remove(key: string): boolean;
+    clear(): boolean;
+}

package/core/gipi-components/types/generic.type.d.ts

@@ -0,0 +1 @@
+export declare type GIPIGenericType<T1, T2> = (T1 extends void ? (T2 extends void ? any : T2) : T1);

package/core/gipi-components/types/uuid.type.d.ts

@@ -0,0 +1 @@
+export declare type GIPIUuid = number | string;

package/core/guards/auth.guard.d.ts

@@ -0,0 +1,11 @@
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import { BaseUser } from '../models/base-user.model';
+import { AuthenticationService } from '../services/authentication.service';
+export declare class AuthGuard implements CanActivate, CanActivateChild {
+    private router;
+    private authenticationService;
+    constructor(router: Router, authenticationService: AuthenticationService<BaseUser>);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+}

package/core/guards/permission.guard.d.ts

@@ -0,0 +1,14 @@
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import { BaseUser } from '../models/base-user.model';
+import { AuthenticationService } from '../services/authentication.service';
+import { MenuDTO } from './../models/dto/menu.dto';
+export declare class PermissionGuard implements CanActivate, CanActivateChild {
+    private router;
+    private authenticationService;
+    constructor(router: Router, authenticationService: AuthenticationService<BaseUser>);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+    hasAuthority(user: any, permission: string): boolean;
+    hasPermission(menuList: MenuDTO[], url: string): boolean;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+}

package/core/guards/public.guard.d.ts

@@ -0,0 +1,11 @@
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import { BaseUser } from '../models/base-user.model';
+import { AuthenticationService } from '../services/authentication.service';
+export declare class PublicGuard implements CanActivate, CanActivateChild {
+    private router;
+    private authenticationService;
+    constructor(router: Router, authenticationService: AuthenticationService<BaseUser>);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+}