@lavalogic/scoria 0.0.1

package/dist/Components/Table/Types/Context/TableInitOptions.d.ts

@@ -0,0 +1,14 @@
+import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
+import type { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
+export interface ITableInitOptions<T extends object> {
+    selectionExtractor: (item: T) => unknown;
+    allowCopy?: boolean;
+    enableResize?: boolean;
+    allowColumnReordering?: boolean;
+    allowQuickFiltering?: boolean;
+    allowAdvancedFiltering?: boolean;
+    toolbar?: ToolbarPosition;
+    displayFooter?: boolean;
+    onEditCell?: (item: T, coords: CellCoordinates, value: unknown) => void | Promise<void>;
+    getUserId: () => string | undefined;
+}

package/dist/Components/Table/Types/Context/TableInitOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/TableSettings.d.ts

@@ -0,0 +1,8 @@
+export interface TableSettings {
+    isCompact: boolean;
+    singleClickEditing: boolean;
+    alternateRowColours: boolean;
+    changeColourOnHover: boolean;
+    copyWithHeaders: boolean;
+    commaSeparatedCopy: boolean;
+}

package/dist/Components/Table/Types/Context/TableSettings.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Coordinates/CellCoordinates.d.ts

@@ -0,0 +1,5 @@
+export interface CellCoordinates {
+    row: number;
+    id: string;
+    column: number;
+}

package/dist/Components/Table/Types/Coordinates/CellCoordinates.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Coordinates/CellCoordinatesWithoutColumn.d.ts

@@ -0,0 +1,2 @@
+import type { CellCoordinates } from './CellCoordinates.js';
+export type CellCoordinatesWithoutColumn = Omit<CellCoordinates, 'column'>;

package/dist/Components/Table/Types/Coordinates/CellCoordinatesWithoutColumn.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/DataRepository/DataRepository.d.ts

@@ -0,0 +1,40 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import type { PaginationState } from '../Pagination/PaginationState.js';
+import type { OnChangeFn } from '../OnChangeFn.js';
+import type { SortingState } from './SortingState.js';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { BoolFilterValueType, DateFilterValueType, FilterFn, NumberFilterValueType, SelectFilterValueType, StringFilterValueType } from '../Filtering/FilterFn.js';
+import type { PaginationType } from '../Pagination/PaginationType.js';
+import type { FilterType } from '../Filtering/FilterType.js';
+export interface DataRepository<T extends object> {
+    paginationState: PaginationState;
+    setPageSize: (size: number) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    updateSorting?: OnChangeFn<SortingState>;
+    manualSorting?: boolean;
+    sorting: SortingState;
+    filtering: ColumnFiltersState;
+    filterModes: SvelteMap<string, FilterMode>;
+    setFilterMode: (id: string, mode: FilterMode) => void;
+    filterBy: (id: string, value: unknown) => void;
+    dateFilter?: FilterFn<T, DateFilterValueType>;
+    numberFilter?: FilterFn<T, NumberFilterValueType>;
+    selectFilter?: FilterFn<T, SelectFilterValueType<T>>;
+    boolFilter?: FilterFn<T, BoolFilterValueType>;
+    stringFilter?: FilterFn<T, StringFilterValueType>;
+    resetFilters: () => void;
+    reload?: () => void;
+    lastPage?: number;
+    pageStartIndex: number;
+    pageEndIndexExclusive: number;
+    previouslyViewedPage: number;
+    readonly paginationType: PaginationType;
+    filterType: FilterType;
+    data: T[];
+    totalRows: number;
+    addEmptyRow?: (() => void) | undefined;
+    isLoading?: boolean;
+}

package/dist/Components/Table/Types/DataRepository/DataRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/DataRepository/LocalDataRepository.d.ts

@@ -0,0 +1,24 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import type { PaginationType } from '../Pagination/PaginationType.js';
+import type { DataRepository } from './DataRepository.js';
+import type { BoolFilterValueType, DateFilterValueType, FilterFn, NumberFilterValueType, SelectFilterValueType, StringFilterValueType } from '../Filtering/FilterFn.js';
+export interface LocalDataRepository<T extends object> extends DataRepository<T> {
+    readonly paginationType: PaginationType.Local;
+    setPageSize: (size: number | string) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    filtering: ColumnFiltersState;
+    filterModes: SvelteMap<string, FilterMode>;
+    setFilterMode: (id: string, mode: FilterMode) => void;
+    filterBy: (id: string, value: unknown) => void;
+    dateFilter: FilterFn<T, DateFilterValueType>;
+    numberFilter: FilterFn<T, NumberFilterValueType>;
+    selectFilter: FilterFn<T, SelectFilterValueType<T>>;
+    boolFilter: FilterFn<T, BoolFilterValueType>;
+    stringFilter: FilterFn<T, StringFilterValueType>;
+    resetFilters: () => void;
+    reload?: () => void;
+}

package/dist/Components/Table/Types/DataRepository/LocalDataRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { RefWrapper } from '../../../../Types/Internal/RefWrapper.js';
+import type { Row } from '../Context/Row.js';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { BoolFilterValueType, NumberFilterValueType, SelectFilterValueType, StringFilterValueType } from '../Filtering/FilterFn.js';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import { FilterType } from '../Filtering/FilterType.js';
+import type { OnChangeFn } from '../OnChangeFn.js';
+import { PaginationType } from '../Pagination/PaginationType.js';
+import type { LocalDataRepository } from './LocalDataRepository.js';
+import type { SortingState } from './SortingState.js';
+import { TableDataRepository } from './TableDataRepository.svelte.js';
+export declare class LocalTableDataRepository<T extends object> extends TableDataRepository<T> implements LocalDataRepository<T> {
+    addEmptyRow?: (() => void) | undefined;
+    readonly filterType = FilterType.Real;
+    constructor(tableName: string, dataRef: RefWrapper<T[]>, // reactive
+    getUserId: () => string | undefined, addEmptyRow?: (() => void) | undefined);
+    private _isLoading;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    readonly onPaginationChange: (...args: unknown[]) => void;
+    private _dataRef;
+    get data(): T[];
+    private _lastPage;
+    get lastPage(): number;
+    private _sorting;
+    get sorting(): SortingState;
+    set sorting(v: SortingState);
+    private _totalRows;
+    get totalRows(): number;
+    private _filtering;
+    get filtering(): ColumnFiltersState;
+    set filtering(v: ColumnFiltersState);
+    updateSorting: OnChangeFn<SortingState>;
+    readonly paginationType: PaginationType.Local;
+    readonly setFilterMode: (id: string, mode: FilterMode | undefined) => void;
+    readonly filterBy: (id: string, value: unknown) => void;
+    private _pageStartIndex;
+    get pageStartIndex(): number;
+    private _pageEndIndexExclusive;
+    get pageEndIndexExclusive(): number;
+    readonly resetFilters: () => void;
+    setPageSize: (size: number | string) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    readonly dateFilter: LocalDataRepository<T>['dateFilter'];
+    readonly numberFilter: (row: Row<T>, columnId: string, // & keyof T,
+    values: NumberFilterValueType) => boolean;
+    readonly selectFilter: <columnType = T[keyof T]>(row: Row<T>, columnId: string, // & keyof T,
+    filterValue: SelectFilterValueType<T>) => boolean;
+    readonly boolFilter: (row: Row<T>, columnId: string, // & keyof T,
+    filterValue: BoolFilterValueType) => boolean;
+    readonly stringFilter: (row: Row<T>, columnId: string, // & keyof T,
+    filterValue: StringFilterValueType) => any;
+}

package/dist/Components/Table/Types/DataRepository/LocalTableDataRepository.svelte.js

@@ -0,0 +1,311 @@
+import { dev } from '$app/environment';
+import { FilterType } from '../Filtering/FilterType.js';
+import { NumberDateFilterMode } from '../Filtering/NumberDateFilterMode.js';
+import { StringFilterMode } from '../Filtering/StringFilterMode.js';
+import { PaginationType } from '../Pagination/PaginationType.js';
+import { TableDataRepository } from './TableDataRepository.svelte.js';
+export class LocalTableDataRepository extends TableDataRepository {
+    addEmptyRow;
+    filterType = FilterType.Real;
+    constructor(tableName, dataRef, // reactive
+    getUserId, addEmptyRow) {
+        super(tableName, getUserId);
+        this.addEmptyRow = addEmptyRow;
+        this._dataRef = $derived(dataRef);
+        this._lastPage = $derived(Math.ceil(this._dataRef.value.length / this.paginationState.pageSize));
+        this._totalRows = $derived(this._dataRef.value?.length ?? -1);
+    }
+    _isLoading = $state(false);
+    get isLoading() {
+        return this._isLoading;
+    }
+    set isLoading(v) {
+        this._isLoading = v;
+    }
+    onPaginationChange = (...args) => {
+        if (dev) {
+            // eslint-disable-next-line no-debugger
+            debugger;
+            console.log(args);
+        }
+    };
+    _dataRef;
+    get data() {
+        return this._dataRef.value;
+    }
+    _lastPage;
+    get lastPage() {
+        return this._lastPage;
+    }
+    _sorting = $state([]);
+    get sorting() {
+        return this._sorting;
+    }
+    set sorting(v) {
+        this._sorting = v;
+    }
+    _totalRows;
+    get totalRows() {
+        return this._totalRows;
+    }
+    // public set totalRows(v : number) {
+    // 	this._totalRows = v;
+    // }
+    _filtering = $state([]);
+    get filtering() {
+        return this._filtering;
+    }
+    set filtering(v) {
+        this._filtering = v;
+    }
+    updateSorting = (stateOrCallback) => {
+        if (typeof stateOrCallback == 'function') {
+            this.sorting = stateOrCallback(this.sorting);
+        }
+        else {
+            this.sorting = stateOrCallback;
+        }
+    };
+    paginationType = PaginationType.Local;
+    setFilterMode = (id, mode) => {
+        if (mode != undefined) {
+            this.filterModes.set(id, mode);
+        }
+        else {
+            this.filterModes.delete(id);
+        }
+    };
+    filterBy = (id, value) => {
+        if (typeof value === 'string') {
+            value = value.trim();
+        }
+        const oldIndex = this.filtering.findIndex((it) => it.id === id);
+        if (oldIndex === -1 || this.filtering[oldIndex].value != value) {
+            if (oldIndex > -1) {
+                this.filtering.splice(oldIndex, 1);
+            }
+            const hasNoValue = value == null ||
+                (typeof value === 'object' && Array.isArray(value) && value.length === 0) ||
+                (typeof value === 'string' && value.length === 0);
+            if (!hasNoValue) {
+                this.filtering.push({ id, value });
+            }
+        }
+        this.filtering = this.filtering.concat();
+    };
+    _pageStartIndex = $derived(this.paginationState.pageIndex * this.paginationState.pageSize);
+    get pageStartIndex() {
+        return this._pageStartIndex;
+    }
+    _pageEndIndexExclusive = $derived((this.paginationState.pageIndex + 1) * this.paginationState.pageSize);
+    get pageEndIndexExclusive() {
+        return this._pageEndIndexExclusive;
+    }
+    resetFilters = () => {
+        this.filtering = [];
+    };
+    setPageSize = (size) => {
+        if (typeof size === 'string') {
+            size = parseInt(size);
+        }
+        if (isNaN(size)) {
+            console.warn('page size is nan');
+            return;
+        }
+        const lastIndex = Math.ceil(this._dataRef.value.length / size) - 1;
+        if (dev) {
+            console.log(`changing page size. Page size is now ${size} and the last page index is ${lastIndex}`);
+        }
+        this.paginationState = {
+            pageSize: size,
+            pageIndex: Math.max(0, Math.min(this.paginationState.pageIndex, lastIndex))
+        };
+    };
+    setPage = (page) => {
+        const lastIndex = this._lastPage - 1;
+        this.paginationState = {
+            ...this.paginationState,
+            pageIndex: Math.max(0, Math.min(lastIndex, page - 1))
+        };
+    };
+    nextPage = () => {
+        const lastIndex = this._lastPage - 1;
+        this.paginationState = {
+            ...this.paginationState,
+            pageIndex: Math.min(lastIndex, this.paginationState.pageIndex + 1)
+        };
+    };
+    prevPage = () => {
+        this.paginationState = {
+            ...this.paginationState,
+            pageIndex: Math.max(0, this.paginationState.pageIndex - 1)
+        };
+    };
+    // #region filters
+    dateFilter = (row, columnId, // & keyof T,
+    [dateFrom, dateTo]) => {
+        if (!dateFrom && !dateTo) {
+            return true;
+        }
+        const columnValue = row.getValue(columnId)?.valueOf();
+        if (!columnValue) {
+            return false;
+        }
+        if (dateFrom) {
+            const fromTimestamp = dateFrom.valueOf();
+            if (dateTo) {
+                const dateToTimestamp = dateTo.valueOf();
+                return columnValue >= fromTimestamp && columnValue <= dateToTimestamp;
+            }
+            else {
+                return columnValue >= fromTimestamp;
+            }
+        }
+        else if (dateTo) {
+            const dateToTimestamp = dateTo.valueOf();
+            return columnValue <= dateToTimestamp;
+        }
+        else {
+            if (dev) {
+                alert('no valid dateFrom or dateTo exist in filter');
+            }
+            //should never happen
+        }
+        return true;
+    };
+    numberFilter = (row, columnId, // & keyof T,
+    values) => {
+        const columnValue = row.getValue(columnId);
+        if (!columnValue) {
+            return false;
+        }
+        const filterType = this.filterModes.get(columnId) ?? NumberDateFilterMode.In;
+        switch (filterType) {
+            case NumberDateFilterMode.Equals: {
+                const [min] = TableDataRepository.getMinMax(values);
+                return min == undefined || columnValue === min;
+            }
+            case NumberDateFilterMode.NotEquals: {
+                const [min] = TableDataRepository.getMinMax(values);
+                return columnValue !== min;
+            }
+            case NumberDateFilterMode.LessThan: {
+                const [min] = TableDataRepository.getMinMax(values);
+                if (min == null) {
+                    return true;
+                }
+                return columnValue < min;
+            }
+            case NumberDateFilterMode.LessThanOrEqual: {
+                const [min] = TableDataRepository.getMinMax(values);
+                if (min == null) {
+                    return true;
+                }
+                return columnValue <= min;
+            }
+            case NumberDateFilterMode.GreaterThan: {
+                const [min] = TableDataRepository.getMinMax(values);
+                if (min == null) {
+                    return true;
+                }
+                return columnValue > min;
+            }
+            case NumberDateFilterMode.GreaterThanOrEqual: {
+                const [min] = TableDataRepository.getMinMax(values);
+                if (min == null) {
+                    return true;
+                }
+                return columnValue >= min;
+            }
+            case NumberDateFilterMode.Between: {
+                const [min, max] = TableDataRepository.getMinMax(values);
+                if (min == null || max == null) {
+                    return true;
+                }
+                return columnValue >= min && columnValue <= max;
+            }
+            case NumberDateFilterMode.In: {
+                const valueSet = this.getValueSet(values);
+                if (valueSet.size === 0) {
+                    return true;
+                }
+                return valueSet.has(columnValue);
+            }
+            case NumberDateFilterMode.NotIn: {
+                const valueSet = this.getValueSet(values);
+                if (valueSet.size === 0) {
+                    return true;
+                }
+                return !valueSet.has(columnValue);
+            }
+            case NumberDateFilterMode.null: {
+                // TODO yes or no setting here
+                return columnValue == null || isNaN(columnValue);
+            }
+            case StringFilterMode.ImplicitEquals:
+            case StringFilterMode.Equals:
+            case StringFilterMode.NotEquals:
+            case StringFilterMode.Contains:
+            case StringFilterMode.NotContains:
+            case StringFilterMode.StartsWith:
+            case StringFilterMode.NotStartsWith:
+            case StringFilterMode.EndsWith:
+            case StringFilterMode.NotEndsWith:
+            case StringFilterMode.In:
+            case StringFilterMode.NotIn:
+            case StringFilterMode.Empty:
+            case StringFilterMode.null:
+                throw new Error('Using string filter mode in a number filter column');
+        }
+        //default
+        return !!values[0] && columnValue.toString().includes(values[0].toString());
+    };
+    selectFilter = (row, columnId, // & keyof T,
+    filterValue) => {
+        if (!filterValue) {
+            return true;
+        }
+        const columnValue = row.getValue(columnId);
+        if (Array.isArray(filterValue)) {
+            return filterValue.find((it) => it === columnValue) != null;
+        }
+        else if (filterValue instanceof Set) {
+            return filterValue.has(columnValue);
+        }
+        if (typeof filterValue === 'object' && 'value' in filterValue) {
+            return filterValue.value === columnValue;
+        }
+        return filterValue == columnValue;
+    };
+    boolFilter = (row, columnId, // & keyof T,
+    filterValue) => {
+        const columnValue = row.getValue(columnId);
+        return filterValue == null || filterValue === columnValue;
+    };
+    stringFilter = (row, columnId, // & keyof T,
+    filterValue) => {
+        if (!filterValue) {
+            return true;
+        }
+        const columnValue = row.getValue(columnId)?.toString().trim().toLocaleLowerCase();
+        if (!columnValue) {
+            return true;
+        }
+        filterValue = filterValue.trim().toLocaleLowerCase();
+        const filterType = this.filterModes.get(columnId) ?? StringFilterMode.Contains;
+        if (filterType === StringFilterMode.EndsWith) {
+            return columnValue.endsWith(filterValue);
+        }
+        if (filterType === StringFilterMode.Equals) {
+            return columnValue === filterValue;
+        }
+        if (filterType === StringFilterMode.StartsWith) {
+            return columnValue.startsWith(filterValue);
+        }
+        if (dev && filterType !== StringFilterMode.Contains) {
+            throw new Error(`unhandled filter type value ${filterType}`);
+        }
+        //default
+        return columnValue.includes(filterValue);
+    };
+}

package/dist/Components/Table/Types/DataRepository/RemoteDataRepository.d.ts

@@ -0,0 +1,19 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { PaginationType } from '../Pagination/PaginationType.js';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import type { DataRepository } from './DataRepository.js';
+export interface RemoteDataRepository<T extends object> extends DataRepository<T> {
+    readonly paginationType: PaginationType.Remote;
+    setPageSize: (size: number | string) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    filtering: ColumnFiltersState;
+    filterModes: SvelteMap<string, FilterMode>;
+    setFilterMode: (id: string, mode: FilterMode) => void;
+    filterBy: (id: string, value: unknown) => void;
+    resetFilters: () => void;
+    lastPage: number;
+    reload?: (debounced?: boolean) => void;
+}

package/dist/Components/Table/Types/DataRepository/RemoteDataRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/DataRepository/RemoteTableDataRepository.svelte.d.ts

@@ -0,0 +1,92 @@
+import type { FloService } from '../../../../Types/Internal/FloService.js';
+import { type TSchema } from '@sinclair/typebox';
+import type { CustomFilterType } from '../Filtering/CustomFilterType.js';
+import type { SelectOption } from '../../../../Types/Internal/SelectOption.js';
+import type { FilterMode } from '../Filtering/FilterMode.js';
+import { TableDataRepository } from './TableDataRepository.svelte.js';
+import type { RemoteDataRepository } from './RemoteDataRepository.js';
+import { PaginationType } from '../Pagination/PaginationType.js';
+import { FilterType } from '../Filtering/FilterType.js';
+import type { SortingState } from './SortingState.js';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { OnChangeFn } from '../OnChangeFn.js';
+import { StringFilterMode } from '../Filtering/StringFilterMode.js';
+import { NumberDateFilterMode } from '../Filtering/NumberDateFilterMode.js';
+import type { IPaginatedResponse } from '../../../../Types/Responses/IPaginatedResponse.js';
+import type { IResponse } from '../../../../Types/Responses/IResponse.js';
+export interface RemoteTableDataRepositoryOptions<httpResponseSchema extends object = object, heldTypeSchema extends object = httpResponseSchema> {
+    uri: string | null;
+    tableName: string;
+    service: FloService;
+    defaultFilters: Map<string, string>;
+    schema?: TSchema;
+    pageSize?: number;
+    fetchImmediately?: boolean;
+    remoteFilters?: CustomRemoteFilters;
+    responseTransformation?: (items: httpResponseSchema[]) => heldTypeSchema[];
+}
+export interface CustomFilter {
+    queryKey: string;
+    type: CustomFilterType;
+    valueAsObject?: boolean;
+    options?: Array<SelectOption<string | number>> | Promise<Array<SelectOption<string | number>>>;
+    multiSelect?: boolean;
+    objectName?: string;
+    label?: string;
+    query?: (value: unknown) => Promise<Array<SelectOption<number>>>;
+}
+export interface CustomProxyFilter extends CustomFilter {
+    service: FloService;
+    endpoint: string;
+    group: unknown;
+    searchValueTransform?: (mode: FilterMode, value: unknown) => Promise<string>;
+    responseValueTransform: (item: unknown) => Promise<[string, unknown[]]>;
+}
+export type CustomRemoteFilters = Map<string, CustomFilter | CustomProxyFilter>;
+export declare class RemoteTableDataRepository<T extends object = object, R extends object = T> extends TableDataRepository<R> implements RemoteDataRepository<R> {
+    options: RemoteTableDataRepositoryOptions<T, R>;
+    private httpGetter;
+    private httpGetterPaginated;
+    static readonly memoise: <T extends object, K extends keyof T, ResponseType>(getter: (item: T) => Promise<ResponseType>, key: K) => (item: T) => Promise<ResponseType>;
+    constructor(options: RemoteTableDataRepositoryOptions<T, R>, getUserId: () => string | undefined, httpGetter: (service: FloService, uri: string) => Promise<IResponse<T[]>>, httpGetterPaginated: (service: FloService, uri: string) => Promise<IPaginatedResponse<T[]>>);
+    private _latestFetchId;
+    private _data;
+    get data(): R[];
+    set data(v: R[]);
+    readonly paginationType = PaginationType.Remote;
+    readonly filterType: FilterType;
+    readonly manualSorting = true;
+    private _sorting;
+    get sorting(): SortingState;
+    set sorting(v: SortingState);
+    private _totalRows;
+    get totalRows(): number;
+    set totalRows(v: number);
+    private _lastPageIndex;
+    private _lastPage;
+    get lastPage(): number;
+    private _isLoadingInternal;
+    private _isLoadingExternal;
+    private _isLoading;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    private _filtering;
+    get filtering(): ColumnFiltersState;
+    set filtering(v: ColumnFiltersState);
+    get pageStartIndex(): number;
+    private _pageEndIndexExclusive;
+    get pageEndIndexExclusive(): number;
+    readonly resetFilters: () => void;
+    updateSorting: OnChangeFn<SortingState>;
+    readonly setFilterMode: (id: string, mode: StringFilterMode | NumberDateFilterMode | undefined) => void;
+    readonly filterBy: (id: string, value: unknown) => void;
+    setPageSize: (size: string | number) => void;
+    setPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    reload: (debounced?: boolean) => void;
+    private previousUri;
+    private _fetch;
+    private _queryString;
+    get queryString(): Promise<string>;
+}