@sarafapp/iron_core 1.0.66 → 1.0.68

package/dist/core/src/baseForm/FormManager.d.ts

@@ -0,0 +1,18 @@
+import { InputControl } from './InputControl';
+import { BaseRequestBodyFilter } from './BaseRequestBodyFilter';
+export declare class FormManager {
+    private _inputControls;
+    private _isValid;
+    private _id;
+    getInputControlsAsArray(): InputControl<unknown>[];
+    runValidation(shouldValidateInputControls?: boolean): Promise<void>;
+    addInputControls(inputControls: InputControl<unknown>[]): void;
+    getInputControl<T>(inputControlName: string): InputControl<T>;
+    resetControls(inputControlNames: string[]): void;
+    resetAll(): void;
+    createRequestBody<T>(requestBodyFilter?: BaseRequestBodyFilter): T;
+    setIsValid(isValid: boolean): void;
+    getIsValid(): boolean;
+    setId(id: number): void;
+    getId(): number;
+}

package/dist/core/src/baseForm/InputControl.d.ts

@@ -0,0 +1,40 @@
+import { Nullable } from '../types';
+import { Validator } from '../validators';
+export declare class InputControl<T> {
+    private initialData;
+    private data;
+    private _validators;
+    private _id;
+    constructor(name: string, value: Nullable<T>);
+    private shouldRunValidation;
+    runValidation(isBlur?: boolean): Promise<void>;
+    private setFormToInvalidState;
+    private setFormToValidState;
+    reset(): void;
+    markAsInitial(): void;
+    setValidators(validators: Validator<T>[]): void;
+    getChangeSensitive(): boolean;
+    setChangeSensitive(isChangeSensitive: boolean): void;
+    getIsBlurSensitive(): boolean;
+    setIsBlurSensitive(isBlurSensitive: boolean): void;
+    getIsRequired(): boolean;
+    setIsRequired(isRequired: boolean): void;
+    getIsValid(): boolean;
+    setIsValid(isValid: boolean): void;
+    getIsIncludeInRequestBody(): boolean;
+    setIsIncludeInRequestBody(isIncludeInRequestBody: boolean): void;
+    getNotValidMessage(): string;
+    setNotValidMessage(notValidMessage: string): void;
+    getName(): string;
+    setName(name: string): void;
+    setId(id: number): void;
+    getId(): number;
+    getIsEmptySensitive(): boolean;
+    setIsEmptySensitive(value: boolean): void;
+    setHasCustomValidationCheck(hasCustomCheck: boolean): void;
+    setShouldRemoveValidationOnInteract(value: boolean): void;
+    getShouldRemoveValidationOnInteract(): boolean;
+    hasCustomValidationCheck(): boolean;
+    set value(value: Nullable<T>);
+    get value(): Nullable<T>;
+}

package/dist/core/src/baseForm/InputControlBuilder.d.ts

@@ -0,0 +1,16 @@
+import { InputControl } from './InputControl';
+import { Validator } from '../validators';
+export declare class InputControlBuilder<T> {
+    private _inputControl;
+    constructor(inputControl: InputControl<T>);
+    setValidators(validators: Validator<T>[]): this;
+    setChangeSensitive(): this;
+    setRequired(): this;
+    setValid(): this;
+    setBlurSensitive(): this;
+    setId(id: number): this;
+    removeEmptySensitive(): this;
+    setHasCustomValidationCheck(): this;
+    removeErrorOnInteract(): this;
+    build(): InputControl<T>;
+}

package/dist/core/src/baseForm/InputControlData.d.ts

@@ -0,0 +1,15 @@
+import { Nullable } from '../types';
+export declare class InputControlData<T> {
+    value: Nullable<T>;
+    initialValue: Nullable<T>;
+    name: string;
+    isValid: boolean;
+    isBlurSensitive: boolean;
+    isRequired: boolean;
+    isIncludeInRequestBody: boolean;
+    isChangeSensitive: boolean;
+    notValidMessage: string;
+    isEmptySensitive: boolean;
+    hasCustomValidationCheck: boolean;
+    shouldRemoveValidationMessageOnInteract: boolean;
+}

package/dist/core/src/baseForm/RequestBodyFilter.d.ts

@@ -0,0 +1,3 @@
+export interface RequestBodyFilter<T> {
+    shouldBeInRequestBody(value: T): boolean;
+}

package/dist/core/src/baseForm/TouchSensitiveForm.d.ts

@@ -0,0 +1,9 @@
+import { DirectiveBinding } from 'vue';
+import { MountedDirective, BeforeUnMountDirective } from '../baseDirective';
+import { InputControl } from './InputControl';
+export declare class TouchSensitiveControl implements MountedDirective, BeforeUnMountDirective {
+    mounted: (element: HTMLInputElement, binding: DirectiveBinding<InputControl<unknown>>) => void;
+    beforeUnMount: (element: HTMLInputElement, binding: DirectiveBinding<InputControl<unknown>>) => void;
+    private handleBlur;
+    private handleFocus;
+}

package/dist/core/src/baseForm/UseForm.d.ts

@@ -0,0 +1,18 @@
+import { FormManager } from './FormManager';
+import { FormValidationStatus } from '../constants';
+export declare function useForm(form: FormManager, hasCustomValidation?: boolean): {
+    reactiveForm: {
+        getInputControlsAsArray: () => import('./InputControl').InputControl<unknown>[];
+        runValidation: (shouldValidateInputControls?: boolean) => Promise<void>;
+        addInputControls: (inputControls: import('./InputControl').InputControl<unknown>[]) => void;
+        getInputControl: <T>(inputControlName: string) => import('./InputControl').InputControl<T>;
+        resetControls: (inputControlNames: string[]) => void;
+        resetAll: () => void;
+        createRequestBody: <T>(requestBodyFilter?: import('./BaseRequestBodyFilter').BaseRequestBodyFilter) => T;
+        setIsValid: (isValid: boolean) => void;
+        getIsValid: () => boolean;
+        setId: (id: number) => void;
+        getId: () => number;
+    };
+    validationStatus: import('vue').Ref<FormValidationStatus, FormValidationStatus>;
+};

package/dist/core/src/baseForm/index.d.ts

@@ -0,0 +1,8 @@
+export { InputControl } from './InputControl';
+export { InputControlBuilder } from './InputControlBuilder';
+export { InputControlData } from './InputControlData';
+export { TouchSensitiveControl } from './TouchSensitiveForm';
+export { FormManager } from './FormManager';
+export { useForm } from './UseForm';
+export { BaseRequestBodyFilter } from './BaseRequestBodyFilter';
+export { type RequestBodyFilter } from './RequestBodyFilter';

package/dist/core/src/baseSchedule/Schedule.d.ts

@@ -0,0 +1,3 @@
+export interface Schedule {
+    runAction: () => Promise<unknown>;
+}

package/dist/core/src/baseSchedule/Scheduler.d.ts

@@ -0,0 +1,8 @@
+import { Schedule } from './Schedule';
+export declare class Scheduler {
+    private timerId;
+    private readonly schedule;
+    constructor(scheduler: Schedule);
+    setupInterval(intervalInMilliseconds: number): void;
+    clearInterval(): void;
+}

package/dist/core/src/baseSchedule/index.d.ts

@@ -0,0 +1,2 @@
+export { type Schedule } from './Schedule';
+export { Scheduler } from './Scheduler';

package/dist/core/src/baseTable/BaseTable.d.ts

@@ -0,0 +1,47 @@
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { LoadingStatus } from '../constants';
+import { Accessible } from '../accessHandling';
+import { TableHeaderSchema } from './TableHeaderSchema';
+import { TableService } from './TableService';
+import { TableAction } from './TableAction';
+import { Nullable } from '../types';
+import { TableSummarySchema } from './TableSummarySchema.ts';
+export declare abstract class BaseTable<Model extends BaseModel> {
+    protected service: TableService<Model>;
+    private accessService;
+    protected currentPage: number;
+    protected currentPageSize: number;
+    private currentSortDetail;
+    protected loadedRows: Model[];
+    headerSchema: TableHeaderSchema<Model>[];
+    protected constructor(service: TableService<Model>);
+    addHeader(schema: TableHeaderSchema<Model>): void;
+    load(): Promise<void>;
+    protected filterItemsBaseOnAccessLevel<T>(items: Accessible[]): T[];
+    sort(sortDetail: SortDetail<Model>): Promise<void>;
+    private shouldSendSortRequest;
+    paginate(nextPage: number, pageSize: number): Promise<void>;
+    private shouldSendPaginationRequest;
+    protected loadRows(): Promise<Model[]>;
+    getData(): import('./TableHeaderSchema').TableRenderingData<Model>;
+    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository').FetchListResponse<Model>>;
+    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository').FetchListResponse<Model>>;
+    getItemCountPerPage(): number;
+    isLoading(): boolean;
+    protected getLoadingStatuses(): Set<LoadingStatus>;
+    hasAnyAction(): boolean;
+    getAccessedActions(row: Model): TableAction<Model>[];
+    protected getActions(row: Model): TableAction<Model>[];
+    getScrollDetail(): Nullable<boolean | {
+        x?: number;
+        y?: number;
+    }>;
+    isExpandable(): boolean;
+    handleClick(row: Model): Promise<void>;
+    handleMetaClick(row: Model): Promise<void>;
+    handleDoubleClick(row: Model): Promise<void>;
+    onDestroy(): Promise<void>;
+    loadHeader(): Promise<TableHeaderSchema<Model>[]>;
+    loadSummarySchema(): TableSummarySchema;
+}

package/dist/core/src/baseTable/Constants.d.ts

@@ -0,0 +1,13 @@
+import { TableHeaderSchema } from './TableHeaderSchema';
+import { BaseModel } from '../BaseModel';
+import { CellType, HeaderType, TableHeaderAlign } from '../constants';
+export declare const TABLE_COLUMN_DEFAULT_WIDTH = "150px";
+export declare const TABLE_COLUMN_DEFAULT_COLSPAN = 2;
+export declare const TABLE_ACTION_COLUMN: TableHeaderSchema<BaseModel>;
+export declare const TABLE_COLUMN_DEFAULT_VALUES: {
+    width: string;
+    align: TableHeaderAlign;
+    headerType: HeaderType;
+    cellType: CellType;
+    colspan: number;
+};

package/dist/core/src/baseTable/OnDestory.d.ts

@@ -0,0 +1,3 @@
+export interface Destroy {
+    onDestroy(): Promise<void>;
+}

package/dist/core/src/baseTable/RowActionSource.d.ts

@@ -0,0 +1,4 @@
+import { TableAction } from './TableAction';
+export interface RowActionSource<Model, A> {
+    getActions(): TableAction<Model, A>[];
+}

package/dist/core/src/baseTable/RowClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowClick<Model> {
+    handleClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/RowDoubleClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowDoubleClick<Model> {
+    handleDoubleClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/RowMetaClick.d.ts

@@ -0,0 +1,3 @@
+export interface RowMetaClick<Model> {
+    handleMetaClick(row: Model): Promise<void>;
+}

package/dist/core/src/baseTable/SelectableTable.d.ts

@@ -0,0 +1,19 @@
+import { BaseTable } from './BaseTable';
+import { BehaviorSubject } from '../observables/BehaviorSubject';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { TableService } from './TableService';
+export declare abstract class SelectableTable<Model extends BaseModel> extends BaseTable<Model> {
+    selectedRows: BehaviorSubject<Map<number, Model>>;
+    constructor(service: TableService<Model>);
+    rowSelect(row: Model): void;
+    selectAll(): void;
+    private isEveryRowSelected;
+    protected handlePagination(nextPage: number, pageSize: number): Promise<import('../repository').FetchListResponse<Model>>;
+    protected handleSort(sortDetail: SortDetail<Model>): Promise<import('../repository').FetchListResponse<Model>>;
+    clearAllSelectedItems(): void;
+    getSelectedRows(): BehaviorSubject<Map<number, Model>>;
+    getSelectedRowsAsArray(): Model[];
+    getSelectedRowIds(): number[];
+    getSelectedRowsValue(): Map<number, Model>;
+}

package/dist/core/src/baseTable/TableAction.d.ts

@@ -0,0 +1,8 @@
+import { Accessible } from '../accessHandling';
+export interface TableAction<Model> extends Accessible {
+    readonly actionName: string;
+    handler(row: Model): Promise<void>;
+}
+export interface ActionDecorator<Model> extends TableAction<Model> {
+    isAvailable(model: Model): boolean;
+}

package/dist/core/src/baseTable/TableHeaderSchema.d.ts

@@ -0,0 +1,27 @@
+import { CellType, HeaderType, LoadingStatus, SortOrder, TableHeaderAlign } from '../constants';
+import { Accessible } from '../accessHandling';
+export interface TableHeaderSchema<Model> extends Accessible {
+    path?: keyof Model;
+    title: string;
+    getProps?: (row: Model) => Record<string, unknown>;
+    key: keyof Model;
+    cellType?: CellType | string;
+    align?: TableHeaderAlign;
+    headerType?: HeaderType;
+    colspan?: number;
+    width?: string | number;
+    ellipsis?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    resizable?: boolean;
+    sortOrder?: SortOrder;
+    sorter?: boolean;
+}
+export interface TableRenderingData<Model> {
+    totalItems: number;
+    currentPage: number;
+    rows: Model[];
+    loadingStatus: Set<LoadingStatus>;
+    currentPageItems: Model[];
+}
+export declare function generateHeader<Model>(header: TableHeaderSchema<Model>): TableHeaderSchema<Model>;

package/dist/core/src/baseTable/TableLoader.d.ts

@@ -0,0 +1,3 @@
+export interface TableLoader<Model> {
+    loadRows(): Promise<Model>;
+}

package/dist/core/src/baseTable/TablePaginate.d.ts

@@ -0,0 +1,3 @@
+export interface TablePaginate {
+    handlePagination(nextPage: number, pageSize: number): Promise<void>;
+}

package/dist/core/src/baseTable/TableService.d.ts

@@ -0,0 +1,9 @@
+import { SortDetail } from '../sort';
+import { FetchListResponse } from '../repository/model';
+import { TableRenderingData } from './TableHeaderSchema';
+export interface TableService<Model> {
+    fetchRows(): Promise<FetchListResponse<Model>>;
+    paginate(nextPage: number, pageSize: number): Promise<FetchListResponse<Model>>;
+    sort(sortDetail: SortDetail<Model>): Promise<FetchListResponse<Model>>;
+    getData(): TableRenderingData<Model>;
+}

package/dist/core/src/baseTable/TableSort.d.ts

@@ -0,0 +1,4 @@
+import { SortDetail } from '../sort';
+export interface TableSort<Model> {
+    handleSort(sortDetail: SortDetail<Model>): Promise<void>;
+}

package/dist/core/src/baseTable/TableSummarySchema.d.ts

@@ -0,0 +1,9 @@
+import { TableHeaderAlign } from '../constants';
+export interface TableSummaryItem {
+    data: string | number;
+    align: TableHeaderAlign;
+}
+export interface TableSummarySchema {
+    summaryTitle: string;
+    summaryItems: TableSummaryItem[];
+}

package/dist/core/src/baseTable/generator/SelectableTableGenerator.d.ts

@@ -0,0 +1,14 @@
+import { TableGenerator } from './TableGenerator';
+import { TableSource } from './TableSource';
+import { BehaviorSubject } from '../../observables';
+export declare class SelectableTableGenerator<T> extends TableGenerator<T> {
+    selectedRows: BehaviorSubject<Map<number, T>>;
+    constructor(tableSource: TableSource<T>);
+    selectRow(row: T): void;
+    selectAll(): void;
+    private isEveryRowSelected;
+    clearAllSelectedItems(): void;
+    getSelectedRows(): Map<number, T>;
+    getSelectedRowsAsArray(): T[];
+    getSelectedRowIds(): number[];
+}

package/dist/core/src/baseTable/generator/TableCellComponentRegistry.d.ts

@@ -0,0 +1,7 @@
+import { Initializer } from '../../initializer';
+export declare abstract class TableCellComponentRegistry implements Initializer {
+    private registeredComponents;
+    initialize(): void;
+    protected abstract registerComponents(): void;
+    getRegisteredComponents(): Map<string, unknown>;
+}

package/dist/core/src/baseTable/generator/TableConfig.d.ts

@@ -0,0 +1,7 @@
+import { TableCellComponentRegistry } from './TableCellComponentRegistry';
+export declare class TableConfig {
+    private cellComponentRegistry;
+    constructor();
+    setCellComponentRegistry(registry: TableCellComponentRegistry): void;
+    getCellComponentRegistry(): TableCellComponentRegistry;
+}

package/dist/core/src/baseTable/generator/TableGenerator.d.ts

@@ -0,0 +1,37 @@
+import { BehaviorSubject } from '../../observables';
+import { SortDetail } from '../../sort';
+import { TableHeaderSchema } from '../TableHeaderSchema';
+import { Nullable } from '../../types';
+import { TableSummarySchema } from '../TableSummarySchema';
+import { TableSource } from './TableSource';
+import { AccessLevel } from '../../accessHandling';
+import { TableAction } from '../TableAction';
+export declare class TableGenerator<T> {
+    rows: BehaviorSubject<T[]>;
+    headerSchema: BehaviorSubject<TableHeaderSchema<T>[]>;
+    currentPage: BehaviorSubject<number>;
+    currentPageSize: BehaviorSubject<number>;
+    totalItems: BehaviorSubject<number>;
+    protected currentSortDetail: BehaviorSubject<SortDetail<T>>;
+    scrollDetail: BehaviorSubject<Nullable<boolean | {
+        x?: number;
+        y?: number;
+    }>>;
+    isExpandable: BehaviorSubject<boolean>;
+    protected tableSource: TableSource<T>;
+    protected accessService: AccessLevel;
+    constructor(tableSource: TableSource<T>);
+    load(): Promise<void>;
+    paginate(nextPage: number, pageSize: number): Promise<void>;
+    private shouldSendPaginationRequest;
+    sort(sortDetail: SortDetail<T>): Promise<void>;
+    private shouldSendSortRequest;
+    handleClick(row: T): Promise<void>;
+    handleMetaClick(row: T): Promise<void>;
+    handleDoubleClick(row: T): Promise<void>;
+    hasAnyAction(): boolean;
+    getRowActions(row: T): TableAction<T>[];
+    loadSummarySchema(): TableSummarySchema;
+    private filterItemsBaseOnAccessLevel;
+    onDestroy(): Promise<void>;
+}

package/dist/core/src/baseTable/generator/TableSource.d.ts

@@ -0,0 +1,24 @@
+import { TableHeaderSchema } from '../TableHeaderSchema';
+import { SortDetail } from '../../sort';
+import { TableSummarySchema } from '../TableSummarySchema';
+import { TableAction } from '../TableAction';
+export interface TableSource<T> {
+    loadRows(): Promise<T[]>;
+    loadHeaderSchema(): Promise<TableHeaderSchema<T>[]>;
+    loadRowActions(row: T): TableAction<T>[];
+    paginate(nextPage: number, pageSize: number): Promise<T[]>;
+    sort(sortDetail: SortDetail<T>): Promise<T[]>;
+    onTableDestroy(): void;
+}
+export interface RowClick<T> extends TableSource<T> {
+    onRowClick(row: T): Promise<void>;
+}
+export interface RowMetaClick<T> extends TableSource<T> {
+    onRowMetaClick(row: T): Promise<void>;
+}
+export interface handleDoubleClick<T> extends TableSource<T> {
+    onRowDoubleClick(row: T): Promise<void>;
+}
+export interface TableSummary<T> extends TableSource<T> {
+    loadSummarySchema(): Promise<TableSummarySchema>;
+}

package/dist/core/src/baseTable/index.d.ts

@@ -0,0 +1,23 @@
+export type { TableAction } from './TableAction';
+export type { TableService } from './TableService';
+export type { Destroy } from './OnDestory';
+export type { RowActionSource } from './RowActionSource';
+export type { TableLoader } from './TableLoader';
+export type { TablePaginate } from './TablePaginate';
+export { TABLE_ACTION_COLUMN, TABLE_COLUMN_DEFAULT_VALUES, TABLE_COLUMN_DEFAULT_COLSPAN, TABLE_COLUMN_DEFAULT_WIDTH, } from './Constants';
+export { BaseTable } from './BaseTable';
+export { SelectableTable } from './SelectableTable';
+export { type TableHeaderSchema, type TableRenderingData, generateHeader, } from './TableHeaderSchema';
+export { type TableSummaryItem, type TableSummarySchema, } from './TableSummarySchema';
+export { Column } from './moduleConnection/Column';
+export { Table } from './moduleConnection/Table';
+export { Action } from './moduleConnection/Action';
+export { TableDestroy } from './moduleConnection/TableDestroy';
+export { TableRowClick } from './moduleConnection/TableRowClick';
+export { type TableSource, type TableSummary, type RowClick, type RowMetaClick, type handleDoubleClick, } from './generator/TableSource';
+export { SelectableTableGenerator } from './generator/SelectableTableGenerator';
+export { TableGenerator } from './generator/TableGenerator';
+export { TableConfig } from './generator/TableConfig';
+export { TableCellComponentRegistry } from './generator/TableCellComponentRegistry';
+export { GColumn } from './moduleConnection/generator/GColumn';
+export { GTable } from './moduleConnection/generator/GTable';

package/dist/core/src/baseTable/moduleConnection/Action.d.ts

@@ -0,0 +1,3 @@
+import { ActionDecorator } from '../TableAction';
+import { BaseModel } from '../../BaseModel';
+export declare function Action<Model extends BaseModel>(actionDetail: Omit<ActionDecorator<Model>, 'handler'>): (target: BaseModel, _propertyKey: string, propertyDescriptor: PropertyDescriptor) => void;

package/dist/core/src/baseTable/moduleConnection/Column.d.ts

@@ -0,0 +1,3 @@
+import { TableHeaderSchema } from '../TableHeaderSchema';
+import { BaseModel } from '../../BaseModel';
+export declare function Column<Model extends BaseModel>(header: TableHeaderSchema<Model>): (target: BaseModel, propertyKey: string) => void;

package/dist/core/src/baseTable/moduleConnection/Table.d.ts

@@ -0,0 +1,4 @@
+import { BaseTable } from '../index';
+import { BaseModel } from '../../BaseModel';
+import { SelectableTable } from '../SelectableTable';
+export declare function Table<Model extends BaseModel>(table: typeof BaseTable<Model> | typeof SelectableTable<Model>): (constructor: Function) => void;

package/dist/core/src/baseTable/moduleConnection/TableDestroy.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../../BaseModel';
+export declare function TableDestroy(): (target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/core/src/baseTable/moduleConnection/TableRowClick.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../../BaseModel';
+export declare function TableRowClick(): (target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/core/src/baseTable/moduleConnection/generator/GColumn.d.ts

@@ -0,0 +1,2 @@
+import { TableHeaderSchema } from '../../index';
+export declare function GColumn<T>(header: TableHeaderSchema<T>): (target: T, propertyKey: string) => void;

package/dist/core/src/baseTable/moduleConnection/generator/GTable.d.ts

@@ -0,0 +1,2 @@
+import { TableSource } from '../../generator/TableSource';
+export declare function GTable<T>(table: new (...args: any[]) => TableSource<T>): (constructor: Function) => void;

package/dist/core/src/composables/UseCrud.d.ts

@@ -0,0 +1,10 @@
+import { BaseModel } from '../BaseModel';
+export declare function useCrud<Entity extends BaseModel>(): {
+    entityItemsAsArray: import('vue').ComputedRef<Entity[]>;
+    addOrReplaceItems: (items: Entity[]) => void;
+    removeById: (id: string | number) => Entity;
+    getItemById: (id: number | string) => Entity;
+    clearItems: () => void;
+    setTotalCount: (count: number) => void;
+    getTotalCount: import('vue').ComputedRef<number>;
+};

package/dist/core/src/composables/UseData.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+import { BaseModel } from '../BaseModel';
+import { Nullable } from '../types';
+export declare function useData<Model extends BaseModel>(): {
+    itemsAsArray: import('vue').ComputedRef<Model[]>;
+    totalCount: Ref<number, number>;
+    currentItem: [Model] extends [Ref<any, any>] ? import('@vue/shared').IfAny<Model, Ref<Model, Model>, Model> : Ref<import('vue').UnwrapRef<Model>, Model | import('vue').UnwrapRef<Model>>;
+    setTotalCount: (totalItems: number) => void;
+    addOrReplaceItems: (itemsToAdd: Model[]) => void;
+    getById: (id: number) => Nullable<Model>;
+    removeById: (id: number) => boolean;
+    clearItems: () => void;
+    setCurrentItem: (item: Nullable<Model>) => void;
+    clearCurrentItem: () => void;
+};

package/dist/core/src/composables/UseLoadingStatus.d.ts

@@ -0,0 +1,15 @@
+import { LoadingStatus } from '../constants';
+export declare function useLoadingStatus(): {
+    loadingStatus: import('vue').Ref<Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>, Set<LoadingStatus> | (Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>)>;
+    isFetchingList: import('vue').ComputedRef<boolean>;
+    isFetchingItem: import('vue').ComputedRef<boolean>;
+    isFetchingLastItems: import('vue').ComputedRef<boolean>;
+    isFetchingPreviousItems: import('vue').ComputedRef<boolean>;
+    isCreating: import('vue').ComputedRef<boolean>;
+    isUpdating: import('vue').ComputedRef<boolean>;
+    isDeleting: import('vue').ComputedRef<boolean>;
+    isSearching: import('vue').ComputedRef<boolean>;
+    isSorting: import('vue').ComputedRef<boolean>;
+    setStatus: (status: LoadingStatus) => void;
+    removeStatus: (status: LoadingStatus) => void;
+};

package/dist/core/src/composables/UseParams.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { Params } from '../repository';
+export declare function useParams(): {
+    params: Ref<Params, Params>;
+    setNextPage: () => void;
+    setPreventPage: () => void;
+    setPageNumber: (pageNumber: number) => void;
+    setItemCount: (itemCount: number) => void;
+    setSortDetail: (sortDetail: SortDetail<BaseModel>) => void;
+    setFilter: (key: string, value: unknown) => void;
+    removeFilter: (key: string) => void;
+    getRequestParams: () => Record<string, unknown>;
+    clearParam: () => void;
+    setFiltersBaseOnRequestBody: (filters: Record<string, unknown>) => void;
+};

package/dist/core/src/composables/UseRepository.d.ts

@@ -0,0 +1,67 @@
+import { Repository } from '../repository';
+import { LoadingStatus } from '../constants';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+import { TableRenderingData, TableService } from '../baseTable';
+export declare function useRepository<Model extends BaseModel>(repository: Repository<Model>): {
+    loadingStatusManager: {
+        loadingStatus: import('vue').Ref<Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>, Set<LoadingStatus> | (Set<LoadingStatus> & Omit<Set<LoadingStatus>, keyof Set<any>>)>;
+        isFetchingList: import('vue').ComputedRef<boolean>;
+        isFetchingItem: import('vue').ComputedRef<boolean>;
+        isFetchingLastItems: import('vue').ComputedRef<boolean>;
+        isFetchingPreviousItems: import('vue').ComputedRef<boolean>;
+        isCreating: import('vue').ComputedRef<boolean>;
+        isUpdating: import('vue').ComputedRef<boolean>;
+        isDeleting: import('vue').ComputedRef<boolean>;
+        isSearching: import('vue').ComputedRef<boolean>;
+        isSorting: import('vue').ComputedRef<boolean>;
+        setStatus: (status: LoadingStatus) => void;
+        removeStatus: (status: LoadingStatus) => void;
+    };
+    dataManger: {
+        itemsAsArray: import('vue').ComputedRef<BaseModel[]>;
+        totalCount: import('vue').Ref<number, number>;
+        currentItem: import('vue').Ref<{
+            id: number | string;
+        }, BaseModel | {
+            id: number | string;
+        }>;
+        setTotalCount: (totalItems: number) => void;
+        addOrReplaceItems: (itemsToAdd: BaseModel[]) => void;
+        getById: (id: number) => BaseModel;
+        removeById: (id: number) => boolean;
+        clearItems: () => void;
+        setCurrentItem: (item: BaseModel) => void;
+        clearCurrentItem: () => void;
+    };
+    paramsManager: {
+        params: import('vue').Ref<import('../repository').Params, import('../repository').Params>;
+        setNextPage: () => void;
+        setPreventPage: () => void;
+        setPageNumber: (pageNumber: number) => void;
+        setItemCount: (itemCount: number) => void;
+        setSortDetail: (sortDetail: SortDetail<BaseModel>) => void;
+        setFilter: (key: string, value: unknown) => void;
+        removeFilter: (key: string) => void;
+        getRequestParams: () => Record<string, unknown>;
+        clearParam: () => void;
+        setFiltersBaseOnRequestBody: (filters: Record<string, unknown>) => void;
+    };
+    tableRenderingData: import('vue').ComputedRef<TableRenderingData<Model>>;
+    fetchList: (loadingStatus?: LoadingStatus) => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchWithAutoRefresh: () => Promise<void>;
+    setupAutoRefresh: () => void;
+    stopAutoRefresh: () => void;
+    fetchItemById: (id: number, shouldRemoveItem?: boolean) => Promise<Model>;
+    createItem: <Body>(body: Body) => Promise<Model>;
+    updateItem: <Body>(id: number, body: Body) => Promise<Model>;
+    deleteItem: (id: number) => Promise<boolean>;
+    fetchLastItems: () => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchPreviousItems: () => Promise<import('../repository').FetchListResponse<Model>>;
+    fetchItemsByPageNumber: (pageNumber: number) => Promise<import('../repository').FetchListResponse<Model>>;
+    search: (searchedValue: string) => Promise<import('../repository').FetchListResponse<Model>>;
+    sort: (sortDetail: SortDetail<Model>) => Promise<import('../repository').FetchListResponse<Model>>;
+    clearFilters: () => Promise<import('../repository').FetchListResponse<Model>>;
+    tableService: import('vue').ComputedRef<TableService<Model>>;
+    currentPageItems: import('vue').ComputedRef<Model[]>;
+};