ng-firebase-table-kxp 1.2.0 → 1.2.2

package/index.d.ts

@@ -1,5 +1,665 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="ng-firebase-table-kxp" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { PipeTransform, OnInit, AfterViewInit, OnChanges, OnDestroy, ElementRef, ChangeDetectorRef, SimpleChanges, EventEmitter } from '@angular/core';
+import { CollectionReference, DocumentReference, QueryDocumentSnapshot, AngularFirestore } from '@angular/fire/compat/firestore';
+import firebase from 'firebase/compat';
+import { OrderByDirection } from 'firebase/firestore';
+import * as i9 from '@angular/material/paginator';
+import { PageEvent, MatPaginator } from '@angular/material/paginator';
+import * as i10 from '@angular/material/sort';
+import { MatSort } from '@angular/material/sort';
+import * as i8 from '@angular/material/table';
+import { MatTableDataSource } from '@angular/material/table';
+import * as i7 from '@angular/router';
+import { Router } from '@angular/router';
+import firebase$1 from 'firebase/compat/app';
+import * as i17 from '@angular/material/dialog';
+import { MatDialog } from '@angular/material/dialog';
+import { ToastrService } from 'ngx-toastr';
+import * as i6 from '@angular/forms';
+import { ValidatorFn, FormGroup, FormArray, FormControl } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i11 from '@angular/material/form-field';
+import * as i12 from '@angular/material/input';
+import * as i13 from '@angular/material/select';
+import * as i14 from '@angular/material/tooltip';
+import * as i15 from '@angular/material/progress-spinner';
+import * as i16 from '@angular/material/icon';
+
+declare class NgFirebaseTableKxpComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgFirebaseTableKxpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgFirebaseTableKxpComponent, "lib-ng-firebase-table-kxp", never, {}, {}, never, never, false, never>;
+}
+
+import WhereFilterOp$1 = firebase.firestore.WhereFilterOp;
+
+declare const TABLE_DEFAULTS: {
+    SORT_FIELD: string;
+    SORT_ORDER: "desc";
+    PAGE_SIZE: number;
+    DEBOUNCE_TIME_MS: number;
+    DEFAULT_BG_COLOR: string;
+    DEFAULT_TEXT_COLOR: string;
+};
+interface TableData {
+    displayedColumns: Column[];
+    filterableOptions?: FilterableOption[];
+    collectionRef: CollectionReference<unknown>;
+    collection: string;
+    name: string;
+    totalRef?: {
+        ref: DocumentReference<unknown>;
+        field: string;
+    }[];
+    download: boolean;
+    pagination: boolean;
+    isNotClickable?: boolean;
+    url?: string;
+    sortBy?: {
+        field: string;
+        order: OrderByDirection;
+    };
+    conditions?: {
+        operator: WhereFilterOp$1;
+        firestoreProperty: string;
+        dashProperty: string | string[];
+    }[];
+    filterFn?: (item: any) => boolean;
+    color?: {
+        bg: string;
+        text: string;
+    };
+    showSimpleSearch?: boolean;
+    actionButton?: {
+        label: string;
+        routerLink: string;
+        icon?: string;
+        colorClass?: string;
+        method?: (row: any, event?: any) => any;
+        condition?: (row?: any) => boolean;
+    };
+    tabs?: Tab;
+}
+interface Tab {
+    method: (tab: any, event?: any) => any;
+    tabsData: TabData[];
+}
+interface TabData {
+    label: string;
+    counter?: number;
+    counterClass?: string;
+}
+interface Column {
+    property: string;
+    title?: string;
+    charLimit?: number;
+    pipe?: PipeTransform;
+    iconClass?: {
+        text?: string;
+        class?: string;
+        condition?: (row: any) => any;
+        buttonMethod?: (row: any, event?: any) => any;
+    }[];
+    isSortable?: boolean;
+    isFilterable?: boolean;
+    isFilterableByDate?: boolean;
+    hasLink?: boolean | string;
+    hasDownload?: boolean | string;
+    relation?: {
+        targetedCollection: string;
+        sourceProperty: string;
+        targetedProperty: string;
+    };
+    queryLength?: {
+        collection: string;
+        property: string;
+        operator: WhereFilterOp$1;
+        value: string;
+    };
+    image?: Image;
+    method?: (row: any, event?: any) => any;
+    filterPredicates?: string[];
+    calculateValue?: (row: any) => any;
+    arrayField?: string;
+    tooltip?: {
+        color: string;
+        text: string;
+    };
+}
+interface Image {
+    class: string;
+    path?: string;
+    url?: boolean;
+    default?: string;
+}
+interface FilterableOption {
+    title: string;
+    items: {
+        property: string;
+        value: string | boolean;
+        label: string;
+    }[];
+}
+interface Pagination {
+    batchSize: number;
+    collection: string;
+    doc?: {
+        firstDoc: QueryDocumentSnapshot<any> | null;
+        lastDoc: QueryDocumentSnapshot<any> | null;
+    };
+    navigation: 'reload' | 'forward' | 'backward';
+    arrange: Arrange;
+    conditions?: Condition[];
+    filterFn?: (item: any) => boolean;
+    size?: number;
+    clientPageIndex?: number;
+}
+interface Condition {
+    operator: WhereFilterOp$1;
+    firestoreProperty: string;
+    dashProperty: string | string[];
+}
+interface Arrange {
+    filters: {
+        arrange: 'ascending' | 'descending' | 'filter' | 'filterByDate' | 'equals' | '';
+        filter?: {
+            property: string;
+            filtering: string;
+        } | null;
+        dateFilter?: {
+            initial: Date;
+            final: Date;
+        };
+    }[];
+    sortBy: {
+        field: string;
+        order: OrderByDirection;
+    };
+    elementId?: {
+        property: string;
+        value: string;
+    };
+}
+type DropdownItem = Column & {
+    arrange: 'filter' | 'filterByDate' | 'equals' | 'ascending' | 'descending';
+    title: string;
+    icon?: string;
+};
+interface FilterSelectItem {
+    property: string;
+    value: string | boolean;
+    label: string;
+}
+
+interface PaginationResult {
+    items: Array<Record<string, unknown> & {
+        id: string;
+    }>;
+    filterLength: number | null;
+    firstDoc: firebase$1.firestore.QueryDocumentSnapshot<unknown> | null;
+    lastDoc: firebase$1.firestore.QueryDocumentSnapshot<unknown> | null;
+    hasNextPage: boolean;
+    hasPreviousPage?: boolean;
+    currentClientPageIndex?: number;
+    totalPages?: number;
+}
+declare class TableService {
+    private ngFire;
+    private dialog;
+    private toastr;
+    constructor(ngFire: AngularFirestore, dialog: MatDialog, toastr: ToastrService);
+    getItems(collection: CollectionReference<unknown>): Promise<Array<Record<string, unknown> & {
+        id: string;
+    }>>;
+    private executeQuery;
+    applyFilters(query: firebase$1.firestore.Query<unknown>, arrange: Arrange, conditions: Condition[] | undefined): firebase$1.firestore.Query<unknown>;
+    private getIdFilter;
+    private getDocumentById;
+    private searchByIdPartial;
+    private shouldUseClientSideFallback;
+    getPaginated(params: Pagination): Promise<PaginationResult>;
+    executeClientSideQuery(params: Pagination): Promise<PaginationResult>;
+    getItemsData(collection: string, arrange: Arrange, conditions?: Condition[] | undefined): Promise<Array<Record<string, unknown> & {
+        id: string;
+    }>>;
+    operators: {
+        '==': (a: unknown, b: unknown) => boolean;
+        '!=': (a: unknown, b: unknown) => boolean;
+        '>': (a: unknown, b: unknown) => boolean;
+        '<': (a: unknown, b: unknown) => boolean;
+        '>=': (a: unknown, b: unknown) => boolean;
+        '<=': (a: unknown, b: unknown) => boolean;
+        in: (a: unknown, b: unknown) => boolean;
+        'not-in': (a: unknown, b: unknown) => boolean;
+        'array-contains': (a: unknown, b: unknown) => boolean;
+        'array-contains-any': (a: unknown, b: unknown) => boolean;
+        includes: (a: unknown, b: unknown) => boolean;
+    };
+    deleteIndex(id: string, col: string): Promise<boolean>;
+    reindex(index: number, col: string, batch: firebase$1.firestore.WriteBatch): Promise<void>;
+    dateFormatValidator(): ValidatorFn;
+    updateIndex(index: number, id: string, col: string): Promise<void>;
+    /**
+     * Extrai o link de criação de índice da mensagem de erro do Firestore
+     */
+    private extractIndexLink;
+    /**
+     * Rastreia índices ausentes ao usar fallback preventivo
+     */
+    private trackMissingIndexPreventive;
+    /**
+     * Gera uma assinatura única para uma query
+     */
+    private generateQuerySignature;
+    /**
+     * Gera instruções claras para criar o índice manualmente
+     */
+    private generateIndexInstructions;
+    /**
+     * Gera um link de índice baseado na estrutura da query
+     */
+    private generateIndexLink;
+    private trackMissingIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableService, [{ optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableService>;
+}
+
+interface FilterConfig {
+    selectFilter: any;
+    typeFilter?: string;
+    selectItem?: any[];
+    initialDate?: string;
+    finalDate?: string;
+}
+interface DateFiltersByProperty {
+    [property: string]: Array<{
+        initial: Date;
+        final: Date;
+    }>;
+}
+interface ProcessedFilter {
+    group: FormGroup;
+    selectedFilter: any;
+    arrange: string;
+}
+declare class FilterService {
+    private tableService;
+    constructor(tableService: TableService);
+    /**
+     * Cria um novo FormGroup para um filtro
+     */
+    createFilterGroup(): FormGroup;
+    /**
+     * Adiciona um novo filtro ao FormArray
+     */
+    addFilter(filtersForm: FormArray, isPaginated: boolean, filterData?: FilterConfig): void;
+    /**
+     * Verifica se há um filtro de data ativo
+     */
+    hasActiveDateFilter(filtersForm: FormArray): boolean;
+    /**
+     * Retorna as opções de filtro disponíveis
+     */
+    getAvailableFilterOptions(dropdownItems: any[], isPaginated: boolean, filtersForm: FormArray): any[];
+    /**
+     * Remove um filtro do FormArray
+     */
+    removeFilter(filtersForm: FormArray, index: number): void;
+    /**
+     * Remove todos os filtros do FormArray
+     */
+    removeAllFilters(filtersForm: FormArray): void;
+    /**
+     * Aplica máscara de data (DD/MM/AAAA)
+     */
+    applyDateMask(event: any, controlName: 'initialDate' | 'finalDate', filterGroup: FormGroup): void;
+    /**
+     * Aplica filtros client-side aos itens
+     */
+    applyClientSideFilters<T = any>(items: T[], filtersForm: FormArray, sortBy: {
+        field: string;
+        order: OrderByDirection;
+    }): T[];
+    /**
+     * Constrói o objeto Arrange a partir dos filtros ativos
+     */
+    buildArrangeFromFilters(filtersForm: FormArray, sortBy: {
+        field: string;
+        order: OrderByDirection;
+    }): Arrange;
+    /**
+     * Extrai filtros ativos para paginação
+     */
+    extractActiveFilters(filtersForm: FormArray): any[];
+    /**
+     * Inicializa os dropdownItems baseado nas colunas
+     */
+    initializeDropdownItems(displayedColumns: Column[]): {
+        dropdownItems: any[];
+        sortableDropdownItems: any[];
+        hasFilterableColumn: boolean;
+        hasSortableColumn: boolean;
+    };
+    /**
+     * Adiciona opções de filtro customizadas
+     */
+    addFilterableOptions(dropdownItems: any[], filterableOptions: any[]): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterService>;
+}
+
+interface TooltipState {
+    hoveredCell: {
+        row: any;
+        col: any;
+    } | null;
+    showTooltip: boolean;
+    tooltipContent: string;
+    tooltipPosition: {
+        x: number;
+        y: number;
+    };
+    tooltipBgColor: string;
+    tooltipBgStyle: {
+        [key: string]: string;
+    } | null;
+    tooltipTextColor: string;
+    tooltipTextStyle: {
+        [key: string]: string;
+    } | null;
+}
+interface TooltipConfig {
+    color?: string;
+    text?: string;
+}
+declare class TooltipService {
+    private tooltipTimeout;
+    /**
+     * Cria um estado inicial para o tooltip
+     */
+    createInitialState(): TooltipState;
+    /**
+     * Processa as cores do tooltip
+     */
+    processTooltipColors(config?: TooltipConfig): {
+        bgColor: string;
+        bgStyle: {
+            [key: string]: string;
+        } | null;
+        textColor: string;
+        textStyle: {
+            [key: string]: string;
+        } | null;
+    };
+    /**
+     * Manipula o evento de mouse enter na célula
+     */
+    handleMouseEnter(event: MouseEvent, row: any, col: Column, getDisplayValue: (col: Column, row: any, withinLimit: boolean) => string, onShow: (state: Partial<TooltipState>) => void): void;
+    /**
+     * Manipula o evento de mouse leave na célula
+     */
+    handleMouseLeave(onHide: (state: TooltipState) => void): void;
+    /**
+     * Manipula o movimento do mouse
+     */
+    handleMouseMove(event: MouseEvent, showTooltip: boolean, onMove: (position: {
+        x: number;
+        y: number;
+    }) => void): void;
+    /**
+     * Combina estilos do tooltip para aplicação
+     */
+    getTooltipStyles(state: TooltipState): {
+        [key: string]: string;
+    };
+    /**
+     * Limpa recursos ao destruir
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;
+}
+
+interface PaginationState {
+    currentPageNumber: number;
+    currentClientPageIndex: number;
+    pageSize: number;
+    totalItems: number;
+    hasNextPage: boolean;
+}
+interface NavigationResult {
+    direction: 'forward' | 'backward' | 'reload';
+    resetDocs: boolean;
+    originalPageSize: number | null;
+    shouldNavigate: boolean;
+    newClientPageIndex: number;
+    newPageNumber: number;
+}
+declare class PaginationService {
+    calculateNavigation(event: PageEvent, currentState: PaginationState): NavigationResult;
+    /**
+     * Calcula o número de itens esperados na última página
+     */
+    calculateLastPageItemCount(totalItems: number, pageSize: number): number;
+    /**
+     * Calcula o índice da última página
+     */
+    calculateLastPageIndex(totalItems: number, pageSize: number): number;
+    /**
+     * Verifica se deve mostrar o botão de próxima página
+     */
+    shouldShowNextButton(hasNextPage: boolean, isPaginated: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationService>;
+}
+
+import WhereFilterOp = firebase.firestore.WhereFilterOp;
+
+declare class TableComponent<T = any> implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private router;
+    private tableService;
+    private filterService;
+    private tooltipService;
+    private paginationService;
+    private firestore;
+    private el;
+    private cdr;
+    data: TableData;
+    downloadTable?: (arrange: Arrange, conditions: Condition[]) => void;
+    arrange: Arrange | null;
+    dataSource: MatTableDataSource<T>;
+    currentPageNumber: number;
+    currentClientPageIndex: number;
+    isLoading$: BehaviorSubject<boolean>;
+    items: T[];
+    filteredItems: T[];
+    private lastDoc;
+    private firstDoc;
+    private sortBy;
+    columnProperties: string[];
+    filtersForm: FormArray;
+    selectSort: FormControl;
+    currentArrange: string;
+    hasNextPage: boolean;
+    dropdownItems: DropdownItem[];
+    sortableDropdownItems: DropdownItem[];
+    pageSize: number;
+    totalItems: number;
+    pageEvent?: PageEvent;
+    filterValue: string | null;
+    hasFilterableColumn: boolean;
+    hasSortableColumn: boolean;
+    filterPredicate: ((data: T, filter: string) => boolean) | undefined;
+    private filterSubject;
+    private readonly debounceTimeMs;
+    selectedTab: number;
+    paginator: MatPaginator;
+    sort: MatSort;
+    tooltipState: TooltipState;
+    imageLoadingState: Map<string, boolean>;
+    private destroy$;
+    constructor(router: Router, tableService: TableService, filterService: FilterService, tooltipService: TooltipService, paginationService: PaginationService, firestore: AngularFirestore, el: ElementRef, cdr: ChangeDetectorRef);
+    getActionButtonClass(): string;
+    getTableRowNgClass(): Record<string, boolean>;
+    getPaginatorNgClass(): Record<string, boolean>;
+    createFilterGroup(): FormGroup;
+    addFilter(filterData?: {
+        selectFilter: DropdownItem | null;
+        typeFilter?: string;
+        selectItem?: FilterSelectItem[];
+        initialDate?: string;
+        finalDate?: string;
+    }): void;
+    hasActiveDateFilter(): boolean;
+    getAvailableFilterOptions(): DropdownItem[];
+    onSelectFilterChange(): void;
+    removeFilter(index: number): void;
+    removeAllFilters(): void;
+    onDateInput(event: Event, controlName: 'initialDate' | 'finalDate', filterIndex: number): void;
+    onDateFilterChange(): void;
+    private applyFiltersToDataSource;
+    private applyClientSideFilters;
+    private buildArrangeFromFilters;
+    getTooltipStyles(): {
+        [key: string]: string;
+    };
+    onCellMouseEnter(event: MouseEvent, row: T, col: Column): void;
+    onCellMouseLeave(): void;
+    onCellMouseMove(event: MouseEvent): void;
+    onTabSelected(event: {
+        tab: TabData;
+        index: number;
+    }): void;
+    getDisplayValue(col: Column, row: T, withinLimit?: boolean): string;
+    getNestedValue(obj: unknown, path: string): unknown;
+    isString(value: unknown): boolean;
+    trackByProperty(_index: number, col: Column): string;
+    private getImageKey;
+    isImageLoading(row: T, col: Column): boolean;
+    onImageLoad(row: T, col: Column): void;
+    onImageError(event: Event, row: T, col: Column, defaultImage?: string): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private applyCustomColors;
+    ngOnInit(): Promise<void>;
+    private loadItems;
+    private loadItemsPaginated;
+    onPageChange(event?: PageEvent): Promise<void>;
+    applyFilter(value: string): void;
+    search(event?: Event): Promise<void>;
+    resetFilter(): Promise<void>;
+    goToDetails(row: T): void;
+    getRelation(params: {
+        id: string;
+        collection: string;
+        newProperty: string;
+    }): Promise<string>;
+    private loadRelations;
+    getQueryLength(params: {
+        item: T;
+        relation: {
+            collection: string;
+            property: string;
+            operator: WhereFilterOp;
+            value: string;
+        };
+    }): Promise<number>;
+    private loadQueryLengths;
+    private filterItems;
+    reloadTable(): Promise<void>;
+    updateDisplayedColumns(): void;
+    shouldShowActionButton(): boolean;
+    handleDownload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "lib-table", never, { "data": { "alias": "data"; "required": false; }; "downloadTable": { "alias": "downloadTable"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TableTabsComponent {
+    tabsData: TabData[];
+    selectedTab: number;
+    tabSelected: EventEmitter<{
+        tab: TabData;
+        index: number;
+    }>;
+    private readonly TABS_PER_GROUP;
+    /**
+     * Retorna os índices dos grupos de tabs (invertidos para exibição vertical)
+     */
+    getTabGroups(): number[];
+    /**
+     * Retorna os tabs de um grupo específico
+     */
+    getTabGroup(groupIndex: number): TabData[];
+    /**
+     * Calcula o índice real do tab considerando a inversão vertical
+     */
+    getRealTabIndex(groupDisplayIndex: number, tabIndexInGroup: number): number;
+    /**
+     * Manipula a seleção de um tab
+     */
+    onTabSelected(groupDisplayIndex: number, tabIndexInGroup: number): void;
+    /**
+     * Verifica se um tab está selecionado
+     */
+    isTabSelected(originalIndex: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableTabsComponent, "lib-table-tabs", never, { "tabsData": { "alias": "tabsData"; "required": false; }; "selectedTab": { "alias": "selectedTab"; "required": false; }; }, { "tabSelected": "tabSelected"; }, never, never, false, never>;
+}
+
+declare class TableTooltipComponent {
+    state: TooltipState;
+    styles: {
+        [key: string]: string;
+    };
+    get showTooltip(): boolean;
+    get tooltipContent(): string;
+    get tooltipPosition(): {
+        x: number;
+        y: number;
+    };
+    get tooltipBgColor(): string;
+    get tooltipTextColor(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableTooltipComponent, "lib-table-tooltip", never, { "state": { "alias": "state"; "required": false; }; "styles": { "alias": "styles"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NgFirebaseTableKxpModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgFirebaseTableKxpModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgFirebaseTableKxpModule, [typeof NgFirebaseTableKxpComponent, typeof TableComponent, typeof TableTabsComponent, typeof TableTooltipComponent], [typeof i5.CommonModule, typeof i6.ReactiveFormsModule, typeof i6.FormsModule, typeof i7.RouterModule, typeof i8.MatTableModule, typeof i9.MatPaginatorModule, typeof i10.MatSortModule, typeof i11.MatFormFieldModule, typeof i12.MatInputModule, typeof i13.MatSelectModule, typeof i14.MatTooltipModule, typeof i15.MatProgressSpinnerModule, typeof i16.MatIconModule, typeof i17.MatDialogModule], [typeof NgFirebaseTableKxpComponent, typeof TableComponent, typeof TableTabsComponent, typeof TableTooltipComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgFirebaseTableKxpModule>;
+}
+
+declare class NgFirebaseTableKxpService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgFirebaseTableKxpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgFirebaseTableKxpService>;
+}
+
+/**
+ * Obtém o valor aninhado de um objeto dado um caminho (ex: 'user.address.city')
+ */
+declare function getNestedValue(obj: any, path: string): any;
+/**
+ * Formata um array de objetos em uma string com valores separados por vírgula
+ */
+declare function formatArrayValue(array: any[], field: string): string;
+/**
+ * Obtém o valor de exibição para uma célula da tabela
+ */
+declare function getDisplayValue(col: Column, row: any, withinLimit?: boolean): string;
+/**
+ * Verifica se um valor é string
+ */
+declare function isString(value: any): boolean;
+/**
+ * TrackBy function para colunas
+ */
+declare function trackByProperty(_index: number, col: Column): string;
+/**
+ * Gera uma chave única para identificar uma imagem em carregamento
+ */
+declare function getImageKey(row: any, col: Column): string;
+
+export { FilterService, NgFirebaseTableKxpComponent, NgFirebaseTableKxpModule, NgFirebaseTableKxpService, PaginationService, TABLE_DEFAULTS, TableComponent, TableService, TableTabsComponent, TableTooltipComponent, TooltipService, formatArrayValue, getDisplayValue, getImageKey, getNestedValue, isString, trackByProperty };
+export type { Arrange, Column, Condition, DateFiltersByProperty, DropdownItem, FilterConfig, FilterSelectItem, FilterableOption, Image, NavigationResult, Pagination, PaginationState, ProcessedFilter, Tab, TabData, TableData, TooltipConfig, TooltipState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-firebase-table-kxp",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Uma biblioteca Angular poderosa para criar tabelas dinâmicas com integração completa ao Firebase Firestore",
   "keywords": [
     "angular",
@@ -32,11 +32,7 @@
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "module": "fesm2015/ng-firebase-table-kxp.mjs",
-  "es2020": "fesm2020/ng-firebase-table-kxp.mjs",
-  "esm2020": "esm2020/ng-firebase-table-kxp.mjs",
-  "fesm2020": "fesm2020/ng-firebase-table-kxp.mjs",
-  "fesm2015": "fesm2015/ng-firebase-table-kxp.mjs",
+  "module": "fesm2022/ng-firebase-table-kxp.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
@@ -44,11 +40,7 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/ng-firebase-table-kxp.mjs",
-      "es2020": "./fesm2020/ng-firebase-table-kxp.mjs",
-      "es2015": "./fesm2015/ng-firebase-table-kxp.mjs",
-      "node": "./fesm2015/ng-firebase-table-kxp.mjs",
-      "default": "./fesm2020/ng-firebase-table-kxp.mjs"
+      "default": "./fesm2022/ng-firebase-table-kxp.mjs"
     }
   },
   "sideEffects": false