@katlux/providers 0.1.0-beta.9 → 0.1.1-alpha.101

package/dist/index.d.cts

@@ -1,3 +1,36 @@
+/**
+ * types.ts — Framework-agnostic hydration and platform abstraction contracts.
+ */
+interface ISSRHydrationAdapter {
+    /**
+     * Retrieve pre-hydrated SSR state for a key. Returns null if not present.
+     */
+    getSSRData<T>(key: string, context?: any): T | null;
+    /**
+     * Execute fetcher with SSR serialization/caching if in an SSR environment,
+     * or simply await fetcher() in standalone/client environments.
+     */
+    fetchWithSSR<T>(key: string, fetcher: () => Promise<T>, context?: any): Promise<T | null>;
+    /**
+     * Invalidate or clear SSR cache for a key (e.g. after mutations).
+     */
+    clearSSRData?(key: string, context?: any): void;
+    /**
+     * Extract SSR hydration payload dictionary (for cache initialization).
+     */
+    getSSRPayload?(context?: any): Record<string, any> | null;
+}
+interface IPlatformRouter {
+    getRoute(): {
+        query: Record<string, any>;
+        path?: string;
+    } | null;
+    getRouter(): any;
+    onReady?(cb: () => void): void;
+}
+
+type TDataProviderListener<T = any> = (provider: T) => void;
+type TUnsubscribe = () => void;
 declare enum EDataFilterOperator {
     Equal = "==",
     NotEqual = "!=",
@@ -35,12 +68,52 @@ interface IRequestOptions {
     cacheKey?: string;
     query?: Record<string, any>;
     deduplicate?: boolean;
-    nuxtApp?: any;
+    context?: any;
     disableCache?: boolean;
+    queue?: boolean;
+    queueLabel?: string;
+    label?: string;
+    tags?: string[];
+    signal?: AbortSignal;
+    _generation?: number;
+}
+/** Queue persistence backend with automatic fallback: IndexedDB → LocalStorage → Memory */
+declare enum EQueueStorage {
+    Memory = "Memory",
+    LocalStorage = "LocalStorage",
+    IndexedDB = "IndexedDB"
+}
+/** Status of an item currently in the pending queue */
+type TQueueItemStatus = 'pending' | 'flushing';
+/** A single mutation operation waiting to be sent */
+interface IQueuedOperation {
+    id: string;
+    url: string;
+    method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    options: IRequestOptions;
+    tags: string[];
+    label?: string;
+    createdAt: number;
+    flushAttempts: number;
+    status: TQueueItemStatus;
+}
+/** An operation that failed permanently and was moved to the dead-letter store */
+interface IDeadLetterItem extends IQueuedOperation {
+    failedAt: number;
+    lastError: string;
+    httpStatus?: number;
+}
+/** Options for flush operations */
+interface IFlushOptions {
+    tag?: string;
 }
 interface IKDatatableAction {
     action: Function;
     label: string;
+    icon?: string;
+    iconOnly?: boolean;
+    type?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark';
+    visible?: Function;
 }
 type TDataRow = {
     [key: string]: any;
@@ -48,54 +121,99 @@ type TDataRow = {
 interface IDataFilter {
     operator: EDataFilterOperator;
     field: TDataRow | IDataFilter[];
-    active: Boolean;
+    active: boolean;
 }
 interface IDataSort {
     field: string;
     direction: 'asc' | 'desc';
 }
-interface IDataResult {
+interface IDataResult<TRow = TDataRow> {
     rowCount: number;
-    rows: TDataRow[];
+    rows: TRow[];
 }
-type TPageDataHandler = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], options?: {
+type TPageDataHandler<TRow = TDataRow> = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], options?: {
     disableCache?: boolean;
-}) => IDataResult | Promise<IDataResult>;
+    signal?: AbortSignal;
+}) => IDataResult<TRow> | Promise<IDataResult<TRow>>;
 interface IDataProviderOptions {
+    idKey?: string;
     filter?: IDataFilter;
     sortList?: IDataSort[];
     pageSize?: number;
     currentPage?: number;
     SSR?: boolean;
+    initialLoad?: boolean;
     cacheStrategy?: ECacheStrategy;
     cacheLifetime?: number;
     deduplicate?: boolean;
-    nuxtApp?: any;
+    context?: any;
+    contextKey?: string;
     urlPageParam?: string;
     refreshOnMutation?: boolean;
 }
-interface ITreeNode {
-    data: TDataRow;
+
+interface ITreeNode<TRow = TDataRow> {
+    data: TRow;
     id: string | number;
     parentId: string | number | null;
     depth: number;
     hasChildren: boolean;
     isExpanded: boolean;
 }
-interface ITreeNodeStatic {
-    data: TDataRow;
+interface ITreeNodeStatic<TRow = TDataRow> {
+    data: TRow;
     id: string | number;
     parentId: string | number | null;
     depth: number;
     hasChildren: boolean;
+    childIds?: (string | number)[];
 }
+/**
+ * A row enriched with tree metadata by a tree data provider
+ */
+type TTreeRow<TRow = TDataRow> = TRow & {
+    id?: string | number;
+    __treeNode?: ITreeNode<TRow>;
+    depth?: number;
+    hasChildren?: boolean;
+    isExpanded?: boolean;
+    parentId?: string | number | null;
+};
 type TreePaginationMode = 'all' | 'root';
+/**
+ * Interface describing a DataProvider with hierarchical tree capabilities
+ */
+interface ITreeDataProvider<TRow = TDataRow> {
+    toggleNode(id: string | number): void;
+    expandedNodes: Set<string | number> | {
+        value: Set<string | number>;
+    };
+    parentKey?: string;
+    expandedByDefault?: boolean;
+    paginateBy?: TreePaginationMode;
+    collapseAll?(): void;
+    expandAll?(): void;
+    isExpanded?(id: string | number): boolean;
+}
 interface ITreeDataProviderOptions extends IDataProviderOptions {
     parentKey?: string;
     idKey?: string;
     expandedByDefault?: boolean;
     paginateBy?: TreePaginationMode;
 }
+/**
+ * Tree-specific page data handler that includes tree parameters
+ * Server handles tree building, visibility, and pagination
+ */
+type TTreePageDataHandler<TRow = TDataRow> = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], treeParams: {
+    expandedNodes: (string | number)[] | Set<string | number>;
+    parentKey: string;
+    idKey: string;
+    paginateBy: TreePaginationMode;
+    expandedByDefault: boolean;
+}, options?: {
+    disableCache?: boolean;
+}) => IDataResult<TRow> | Promise<IDataResult<TRow>>;
 interface KProductItemData {
     id: string | number;
     title: string;
@@ -112,1477 +230,145 @@ interface KProductRowAction {
     color?: 'primary' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark' | 'default';
 }
 
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LooseRequired<T> = {
-    [P in keyof (T & Required<T>)]: T[P];
-};
-type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
-
-declare enum TrackOpTypes {
-    GET = "get",
-    HAS = "has",
-    ITERATE = "iterate"
-}
-declare enum TriggerOpTypes {
-    SET = "set",
-    ADD = "add",
-    DELETE = "delete",
-    CLEAR = "clear"
-}
-
-type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
-declare const ShallowReactiveMarker: unique symbol;
-type Primitive = string | number | boolean | bigint | symbol | undefined | null;
-type Builtin = Primitive | Function | Date | Error | RegExp;
-
-type EffectScheduler = (...args: any[]) => any;
-type DebuggerEvent = {
-    effect: Subscriber;
-} & DebuggerEventExtraInfo;
-type DebuggerEventExtraInfo = {
-    target: object;
-    type: TrackOpTypes | TriggerOpTypes;
-    key: any;
-    newValue?: any;
-    oldValue?: any;
-    oldTarget?: Map<any, any> | Set<any>;
-};
-interface DebuggerOptions {
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-}
-interface ReactiveEffectOptions extends DebuggerOptions {
-    scheduler?: EffectScheduler;
-    allowRecurse?: boolean;
-    onStop?: () => void;
-}
-/**
- * Subscriber is a type that tracks (or subscribes to) a list of deps.
- */
-interface Subscriber extends DebuggerOptions {
-}
-declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
-    fn: () => T;
-    scheduler?: EffectScheduler;
-    onStop?: () => void;
-    onTrack?: (event: DebuggerEvent) => void;
-    onTrigger?: (event: DebuggerEvent) => void;
-    constructor(fn: () => T);
-    pause(): void;
-    resume(): void;
-    run(): T;
-    stop(): void;
-    trigger(): void;
-    get dirty(): boolean;
-}
-type ComputedGetter<T> = (oldValue?: T) => T;
-type ComputedSetter<T> = (newValue: T) => void;
-interface WritableComputedOptions<T, S = T> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<S>;
-}
-
-declare const RefSymbol: unique symbol;
-declare const RawSymbol: unique symbol;
-interface Ref<T = any, S = T> {
-    get value(): T;
-    set value(_: S);
-    /**
-     * Type differentiator only.
-     * We need this to be in public d.ts but don't want it to show up in IDE
-     * autocomplete, so we use a private Symbol instead.
-     */
-    [RefSymbol]: true;
-}
-declare const ShallowRefMarker: unique symbol;
-type ShallowRef<T = any, S = T> = Ref<T, S> & {
-    [ShallowRefMarker]?: true;
-};
-/**
- * This is a special exported interface for other packages to declare
- * additional types that should bail out for ref unwrapping. For example
- * \@vue/runtime-dom can declare it like so in its d.ts:
- *
- * ``` ts
- * declare module '@vue/reactivity' {
- *   export interface RefUnwrapBailTypes {
- *     runtimeDOMBailTypes: Node | Window
- *   }
- * }
- * ```
- */
-interface RefUnwrapBailTypes {
-}
-type ShallowUnwrapRef<T> = {
-    [K in keyof T]: DistributeRef<T[K]>;
-};
-type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
-type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
-type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
-    [RawSymbol]?: true;
-} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
-    [K in keyof T]: UnwrapRefSimple<T[K]>;
-} : T extends object & {
-    [ShallowReactiveMarker]?: never;
-} ? {
-    [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
-} : T;
-type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
-type OnCleanup = (cleanupFn: () => void) => void;
-type WatchStopHandle = () => void;
-
-type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
-type InternalSlots = {
-    [name: string]: Slot | undefined;
-};
-type Slots = Readonly<InternalSlots>;
-declare const SlotSymbol: unique symbol;
-type SlotsType<T extends Record<string, any> = Record<string, any>> = {
-    [SlotSymbol]?: T;
-};
-type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
-type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{
-    [K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? T[K] : Slot<T[K]>;
-}>>;
-type RawSlots = {
-    [name: string]: unknown;
-    $stable?: boolean;
-};
-
-declare enum SchedulerJobFlags {
-    QUEUED = 1,
-    PRE = 2,
-    /**
-     * Indicates whether the effect is allowed to recursively trigger itself
-     * when managed by the scheduler.
-     *
-     * By default, a job cannot trigger itself because some built-in method calls,
-     * e.g. Array.prototype.push actually performs reads as well (#1740) which
-     * can lead to confusing infinite loops.
-     * The allowed cases are component update functions and watch callbacks.
-     * Component update functions may update child component props, which in turn
-     * trigger flush: "pre" watch callbacks that mutates state that the parent
-     * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
-     * triggers itself again, it's likely intentional and it is the user's
-     * responsibility to perform recursive state mutation that eventually
-     * stabilizes (#1727).
-     */
-    ALLOW_RECURSE = 4,
-    DISPOSED = 8
-}
-interface SchedulerJob extends Function {
-    id?: number;
-    /**
-     * flags can technically be undefined, but it can still be used in bitwise
-     * operations just like 0.
-     */
-    flags?: SchedulerJobFlags;
-    /**
-     * Attached by renderer.ts when setting up a component's render effect
-     * Used to obtain component information when reporting max recursive updates.
-     */
-    i?: ComponentInternalInstance;
-}
-declare function nextTick(): Promise<void>;
-declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>;
-
-type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
-type ComponentObjectPropsOptions<P = Data> = {
-    [K in keyof P]: Prop<P[K]> | null;
-};
-type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
-type DefaultFactory<T> = (props: Data) => T | null | undefined;
-interface PropOptions<T = any, D = T> {
-    type?: PropType<T> | true | null;
-    required?: boolean;
-    default?: D | DefaultFactory<D> | null | undefined | object;
-    validator?(value: unknown, props: Data): boolean;
-}
-type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
-type PropConstructor<T = any> = {
-    new (...args: any[]): T & {};
-} | {
-    (): T;
-} | PropMethod<T>;
-type PropMethod<T, TConstructor = any> = [T] extends [
-    ((...args: any) => any) | undefined
-] ? {
-    new (): TConstructor;
-    (): T;
-    readonly prototype: TConstructor;
-} : never;
-type RequiredKeys<T> = {
-    [K in keyof T]: T[K] extends {
-        required: true;
-    } | {
-        default: any;
-    } | BooleanConstructor | {
-        type: BooleanConstructor;
-    } ? T[K] extends {
-        default: undefined | (() => undefined);
-    } ? never : K : never;
-}[keyof T];
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-type DefaultKeys<T> = {
-    [K in keyof T]: T[K] extends {
-        default: any;
-    } | BooleanConstructor | {
-        type: BooleanConstructor;
-    } ? T[K] extends {
-        type: BooleanConstructor;
-        required: true;
-    } ? never : K : never;
-}[keyof T];
-type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
-    type: null | true;
-}] ? any : [T] extends [ObjectConstructor | {
-    type: ObjectConstructor;
-}] ? Record<string, any> : [T] extends [BooleanConstructor | {
-    type: BooleanConstructor;
-}] ? boolean : [T] extends [DateConstructor | {
-    type: DateConstructor;
-}] ? Date : [T] extends [(infer U)[] | {
-    type: (infer U)[];
-}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : T;
-/**
- * Extract prop types from a runtime props options object.
- * The extracted types are **internal** - i.e. the resolved props received by
- * the component.
- * - Boolean props are always present
- * - Props with default values are always present
- *
- * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
- */
-type ExtractPropTypes<O> = {
-    [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
-        default: any;
-    } ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]>;
-} & {
-    [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>;
-};
-type ExtractDefaultPropTypes<O> = O extends object ? {
-    [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
-} : {};
-
-/**
- * Vue `<script setup>` compiler macro for declaring component props. The
- * expected argument is the same as the component `props` option.
- *
- * Example runtime declaration:
- * ```js
- * // using Array syntax
- * const props = defineProps(['foo', 'bar'])
- * // using Object syntax
- * const props = defineProps({
- *   foo: String,
- *   bar: {
- *     type: Number,
- *     required: true
- *   }
- * })
- * ```
- *
- * Equivalent type-based declaration:
- * ```ts
- * // will be compiled into equivalent runtime declarations
- * const props = defineProps<{
- *   foo?: string
- *   bar: number
- * }>()
- * ```
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- */
-declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{
-    [key in PropNames]?: any;
-}>>;
-declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
-declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
-type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
-    readonly [K in BKeys]-?: boolean;
-};
-type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's emitted
- * events. The expected argument is the same as the component `emits` option.
- *
- * Example runtime declaration:
- * ```js
- * const emit = defineEmits(['change', 'update'])
- * ```
- *
- * Example type-based declaration:
- * ```ts
- * const emit = defineEmits<{
- *   // <eventName>: <expected arguments>
- *   change: []
- *   update: [value: number] // named tuple syntax
- * }>()
- *
- * emit('change')
- * emit('update', 1)
- * ```
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
- */
-declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
-declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
-declare function defineEmits<T extends ComponentTypeEmits>(): T extends (...args: any[]) => any ? T : ShortEmits<T>;
-type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
-type RecordToUnion<T extends Record<string, any>> = T[keyof T];
-type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{
-    [K in keyof T]: (evt: K, ...args: T[K]) => void;
-}>>;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's exposed
- * instance properties when it is accessed by a parent component via template
- * refs.
- *
- * `<script setup>` components are closed by default - i.e. variables inside
- * the `<script setup>` scope is not exposed to parent unless explicitly exposed
- * via `defineExpose`.
- *
- * This is only usable inside `<script setup>`, is compiled away in the
- * output and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
- */
-declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
-/**
- * Vue `<script setup>` compiler macro for declaring a component's additional
- * options. This should be used only for options that cannot be expressed via
- * Composition API - e.g. `inheritAttrs`.
- *
- * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
- */
-declare function defineOptions<RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsBase<{}, RawBindings, D, C, M, Mixin, Extends, {}> & {
-    /**
-     * props should be defined via defineProps().
-     */
-    props?: never;
-    /**
-     * emits should be defined via defineEmits().
-     */
-    emits?: never;
-    /**
-     * expose should be defined via defineExpose().
-     */
-    expose?: never;
-    /**
-     * slots should be defined via defineSlots().
-     */
-    slots?: never;
-}): void;
-declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
-type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [
-    ModelRef<T, M, G, S>,
-    Record<M, true | undefined>
-];
-type DefineModelOptions<T = any, G = T, S = T> = {
-    get?: (v: T) => G;
-    set?: (v: S) => any;
-};
-/**
- * Vue `<script setup>` compiler macro for declaring a
- * two-way binding prop that can be consumed via `v-model` from the parent
- * component. This will declare a prop with the same name and a corresponding
- * `update:propName` event.
- *
- * If the first argument is a string, it will be used as the prop name;
- * Otherwise the prop name will default to "modelValue". In both cases, you
- * can also pass an additional object which will be used as the prop's options.
- *
- * The returned ref behaves differently depending on whether the parent
- * provided the corresponding v-model props or not:
- * - If yes, the returned ref's value will always be in sync with the parent
- *   prop.
- * - If not, the returned ref will behave like a normal local ref.
- *
- * @example
- * ```ts
- * // default model (consumed via `v-model`)
- * const modelValue = defineModel<string>()
- * modelValue.value = "hello"
- *
- * // default model with options
- * const modelValue = defineModel<string>({ required: true })
- *
- * // with specified name (consumed via `v-model:count`)
- * const count = defineModel<number>('count')
- * count.value++
- *
- * // with specified name and default value
- * const count = defineModel<number>('count', { default: 0 })
- * ```
- */
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: ({
-    default: any;
-} | {
-    required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: ({
-    default: any;
-} | {
-    required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
-type NotUndefined<T> = T extends undefined ? never : T;
-type MappedOmit<T, K extends keyof any> = {
-    [P in keyof T as P extends K ? never : P]: T[P];
-};
-type InferDefaults<T> = {
-    [K in keyof T]?: InferDefault<T, T[K]>;
-};
-type NativeType = null | undefined | number | string | boolean | symbol | Function;
-type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
-type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & {
-    readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never;
-} & {
-    readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean;
-} : never;
-/**
- * Vue `<script setup>` compiler macro for providing props default values when
- * using type-based `defineProps` declaration.
- *
- * Example usage:
- * ```ts
- * withDefaults(defineProps<{
- *   size?: number
- *   labels?: string[]
- * }>(), {
- *   size: 3,
- *   labels: () => ['default label']
- * })
- * ```
- *
- * This is only usable inside `<script setup>`, is compiled away in the output
- * and should **not** be actually called at runtime.
- *
- * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
- */
-declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
-
-type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
-type EmitsOptions = ObjectEmitsOptions | string[];
-type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? {
-    [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
-} : T extends ObjectEmitsOptions ? {
-    [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : never) => any;
-} : {};
-type ShortEmitsToObject<E> = E extends Record<string, any[]> ? {
-    [K in keyof E]: (...args: E[K]) => any;
-} : E;
-type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
-    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void;
-}[Event]>;
-
-/**
-Runtime helper for applying directives to a vnode. Example usage:
-
-const comp = resolveComponent('comp')
-const foo = resolveDirective('foo')
-const bar = resolveDirective('bar')
-
-return withDirectives(h(comp), [
-  [foo, this.x],
-  [bar, this.y]
-])
-*/
-
-interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg = any> {
-    instance: ComponentPublicInstance | Record<string, any> | null;
-    value: Value;
-    oldValue: Value | null;
-    arg?: Arg;
-    modifiers: DirectiveModifiers<Modifiers>;
-    dir: ObjectDirective<any, Value, Modifiers, Arg>;
-}
-type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Value = any, Modifiers extends string = string, Arg = any> = (el: HostElement, binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode<any, HostElement>, prevVNode: Prev) => void;
-type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg = any> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data | undefined;
-interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> {
-    created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-    beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-    mounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-    beforeUpdate?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
-    updated?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
-    beforeUnmount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-    unmounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
-    getSSRProps?: SSRDirectiveHook<Value, Modifiers, Arg>;
-    deep?: boolean;
-}
-type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg = any> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
-type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
-type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>;
-
-/**
- * Custom properties added to component instances in any way and can be accessed through `this`
- *
- * @example
- * Here is an example of adding a property `$router` to every component instance:
- * ```ts
- * import { createApp } from 'vue'
- * import { Router, createRouter } from 'vue-router'
- *
- * declare module 'vue' {
- *   interface ComponentCustomProperties {
- *     $router: Router
- *   }
- * }
- *
- * // effectively adding the router to every component instance
- * const app = createApp({})
- * const router = createRouter()
- * app.config.globalProperties.$router = router
- *
- * const vm = app.mount('#app')
- * // we can access the router from the instance
- * vm.$router.push('/')
- * ```
- */
-interface ComponentCustomProperties {
-}
-type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
-type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any, any, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
-type ExtractMixin<T> = {
-    Mixin: MixinToOptionTypes<T>;
-}[T extends ComponentOptionsMixin ? 'Mixin' : never];
-type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType : UnionToIntersection<ExtractMixin<T>>;
-type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
-type EnsureNonVoid<T> = T extends void ? {} : T;
-type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props, RawBindings, D, C, M> = ComponentPublicInstance<any>, Props = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions> = {
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-    new (...args: any[]): T;
-};
-/**
- * This is the same as `CreateComponentPublicInstance` but adds local components,
- * global directives, exposed, and provide inference.
- * It changes the arguments order so that we don't need to repeat mixin
- * inference everywhere internally, but it has to be a new type to avoid
- * breaking types that relies on previous arguments order (#10842)
- */
-type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
-type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
-type ComponentPublicInstance<P = {}, // props type extracted from props option
-B = {}, // raw bindings returned from setup()
-D = {}, // return from data()
-C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}, TypeEl extends Element = any> = {
-    $: ComponentInternalInstance;
-    $data: D;
-    $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
-    $attrs: Data;
-    $refs: Data & TypeRefs;
-    $slots: UnwrapSlotsType<S>;
-    $root: ComponentPublicInstance | null;
-    $parent: ComponentPublicInstance | null;
-    $host: Element | null;
-    $emit: EmitFn<E>;
-    $el: TypeEl;
-    $options: Options & MergedComponentOptionsOverride;
-    $forceUpdate: () => void;
-    $nextTick: typeof nextTick;
-    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
-} & ExposedKeys<IfAny<P, P, Readonly<Defaults> & Omit<P, keyof ShallowUnwrapRef<B> | keyof Defaults>> & ShallowUnwrapRef<B> & UnwrapNestedRefs<D> & ExtractComputedReturns<C> & M & ComponentCustomProperties & InjectToObject<I>, Exposed>;
-
-interface SuspenseProps {
-    onResolve?: () => void;
-    onPending?: () => void;
-    onFallback?: () => void;
-    timeout?: string | number;
-    /**
-     * Allow suspense to be captured by parent suspense
-     *
-     * @default false
-     */
-    suspensible?: boolean;
-}
-declare const SuspenseImpl: {
-    name: string;
-    __isSuspense: boolean;
-    process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
-    hydrate: typeof hydrateSuspense;
-    normalize: typeof normalizeSuspenseChildren;
-};
-declare const Suspense: {
-    __isSuspense: true;
-    new (): {
-        $props: VNodeProps & SuspenseProps;
-        $slots: {
-            default(): VNode[];
-            fallback(): VNode[];
-        };
-    };
-};
-interface SuspenseBoundary {
-    vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
-    parent: SuspenseBoundary | null;
-    parentComponent: ComponentInternalInstance | null;
-    namespace: ElementNamespace;
-    container: RendererElement;
-    hiddenContainer: RendererElement;
-    activeBranch: VNode | null;
-    pendingBranch: VNode | null;
-    deps: number;
-    pendingId: number;
-    timeout: number;
-    isInFallback: boolean;
-    isHydrating: boolean;
-    isUnmounted: boolean;
-    effects: Function[];
-    resolve(force?: boolean, sync?: boolean): void;
-    fallback(fallbackVNode: VNode): void;
-    move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void;
-    next(): RendererNode | null;
-    registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn, optimized: boolean): void;
-    unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
-}
-declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
-declare function normalizeSuspenseChildren(vnode: VNode): void;
-
-type Hook<T = () => void> = T | T[];
-interface BaseTransitionProps<HostElement = RendererElement> {
-    mode?: 'in-out' | 'out-in' | 'default';
-    appear?: boolean;
-    persisted?: boolean;
-    onBeforeEnter?: Hook<(el: HostElement) => void>;
-    onEnter?: Hook<(el: HostElement, done: () => void) => void>;
-    onAfterEnter?: Hook<(el: HostElement) => void>;
-    onEnterCancelled?: Hook<(el: HostElement) => void>;
-    onBeforeLeave?: Hook<(el: HostElement) => void>;
-    onLeave?: Hook<(el: HostElement, done: () => void) => void>;
-    onAfterLeave?: Hook<(el: HostElement) => void>;
-    onLeaveCancelled?: Hook<(el: HostElement) => void>;
-    onBeforeAppear?: Hook<(el: HostElement) => void>;
-    onAppear?: Hook<(el: HostElement, done: () => void) => void>;
-    onAfterAppear?: Hook<(el: HostElement) => void>;
-    onAppearCancelled?: Hook<(el: HostElement) => void>;
-}
-interface TransitionHooks<HostElement = RendererElement> {
-    mode: BaseTransitionProps['mode'];
-    persisted: boolean;
-    beforeEnter(el: HostElement): void;
-    enter(el: HostElement): void;
-    leave(el: HostElement, remove: () => void): void;
-    clone(vnode: VNode): TransitionHooks<HostElement>;
-    afterLeave?(): void;
-    delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void;
-    delayedLeave?(): void;
-}
-type ElementNamespace = 'svg' | 'mathml' | undefined;
-interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
-    patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, parentComponent?: ComponentInternalInstance | null): void;
-    insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
-    remove(el: HostNode): void;
-    createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
-        [key: string]: any;
-    }) | null): HostElement;
-    createText(text: string): HostNode;
-    createComment(text: string): HostNode;
-    setText(node: HostNode, text: string): void;
-    setElementText(node: HostElement, text: string): void;
-    parentNode(node: HostNode): HostElement | null;
-    nextSibling(node: HostNode): HostNode | null;
-    querySelector?(selector: string): HostElement | null;
-    setScopeId?(el: HostElement, id: string): void;
-    cloneNode?(node: HostNode): HostNode;
-    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
-}
-interface RendererNode {
-    [key: string | symbol]: any;
-}
-interface RendererElement extends RendererNode {
-}
-interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
-    p: PatchFn;
-    um: UnmountFn;
-    r: RemoveFn;
-    m: MoveFn;
-    mt: MountComponentFn;
-    mc: MountChildrenFn;
-    pc: PatchChildrenFn;
-    pbc: PatchBlockChildrenFn;
-    n: NextFn;
-    o: RendererOptions<HostNode, HostElement>;
-}
-type PatchFn = (n1: VNode | null, // null means this is a mount
-n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
-type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
-type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
-type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
-type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
-type NextFn = (vnode: VNode) => RendererNode | null;
-type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
-type RemoveFn = (vnode: VNode) => void;
-type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
-type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
-declare enum MoveType {
-    ENTER = 0,
-    LEAVE = 1,
-    REORDER = 2
-}
-
-type MatchPattern = string | RegExp | (string | RegExp)[];
-interface KeepAliveProps {
-    include?: MatchPattern;
-    exclude?: MatchPattern;
-    max?: number | string;
-}
-type DebuggerHook = (e: DebuggerEvent) => void;
-type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
-
-declare enum DeprecationTypes$1 {
-    GLOBAL_MOUNT = "GLOBAL_MOUNT",
-    GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
-    GLOBAL_EXTEND = "GLOBAL_EXTEND",
-    GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE",
-    GLOBAL_SET = "GLOBAL_SET",
-    GLOBAL_DELETE = "GLOBAL_DELETE",
-    GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE",
-    GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL",
-    CONFIG_SILENT = "CONFIG_SILENT",
-    CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS",
-    CONFIG_KEY_CODES = "CONFIG_KEY_CODES",
-    CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP",
-    CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS",
-    CONFIG_WHITESPACE = "CONFIG_WHITESPACE",
-    CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS",
-    INSTANCE_SET = "INSTANCE_SET",
-    INSTANCE_DELETE = "INSTANCE_DELETE",
-    INSTANCE_DESTROY = "INSTANCE_DESTROY",
-    INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER",
-    INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS",
-    INSTANCE_CHILDREN = "INSTANCE_CHILDREN",
-    INSTANCE_LISTENERS = "INSTANCE_LISTENERS",
-    INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS",
-    INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE",
-    OPTIONS_DATA_FN = "OPTIONS_DATA_FN",
-    OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE",
-    OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY",
-    OPTIONS_DESTROYED = "OPTIONS_DESTROYED",
-    WATCH_ARRAY = "WATCH_ARRAY",
-    PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS",
-    V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER",
-    CUSTOM_DIR = "CUSTOM_DIR",
-    ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE",
-    ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION",
-    TRANSITION_CLASSES = "TRANSITION_CLASSES",
-    TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT",
-    COMPONENT_ASYNC = "COMPONENT_ASYNC",
-    COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL",
-    COMPONENT_V_MODEL = "COMPONENT_V_MODEL",
-    RENDER_FUNCTION = "RENDER_FUNCTION",
-    FILTERS = "FILTERS",
-    PRIVATE_APIS = "PRIVATE_APIS"
-}
-type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
-    MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
-};
-
-/**
- * Interface for declaring custom options.
- *
- * @example
- * ```ts
- * declare module 'vue' {
- *   interface ComponentCustomOptions {
- *     beforeRouteUpdate?(
- *       to: Route,
- *       from: Route,
- *       next: () => void
- *     ): void
- *   }
- * }
- * ```
- */
-interface ComponentCustomOptions {
-}
-type RenderFunction = () => VNodeChild;
-interface ComponentOptionsBase<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props, D, C, M, Mixin, Extends, I, II, Provide>, ComponentInternalOptions, ComponentCustomOptions {
-    setup?: (this: void, props: LooseRequired<Props & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
-    name?: string;
-    template?: string | object;
-    render?: Function;
-    components?: LC & Record<string, Component>;
-    directives?: Directives & Record<string, Directive>;
-    inheritAttrs?: boolean;
-    emits?: (E | EE[]) & ThisType<void>;
-    slots?: S;
-    expose?: Exposed[];
-    serverPrefetch?(): void | Promise<any>;
-    compilerOptions?: RuntimeCompilerOptions;
-    call?: (this: unknown, ...args: unknown[]) => never;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-    __defaults?: Defaults;
-}
-/**
- * Subset of compiler options that makes sense for the runtime.
- */
-interface RuntimeCompilerOptions {
-    isCustomElement?: (tag: string) => boolean;
-    whitespace?: 'preserve' | 'condense';
-    comments?: boolean;
-    delimiters?: [string, string];
-}
-type ComponentOptions<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = any, M extends MethodOptions = any, Mixin extends ComponentOptionsMixin = any, Extends extends ComponentOptionsMixin = any, E extends EmitsOptions = any, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> = ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II, S, LC, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<{}, RawBindings, D, C, M, Mixin, Extends, E, Readonly<Props>, Defaults, false, I, S, LC, Directives>>;
-type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
-type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
-interface MethodOptions {
-    [key: string]: Function;
-}
-type ExtractComputedReturns<T extends any> = {
-    [key in keyof T]: T[key] extends {
-        get: (...args: any[]) => infer TReturn;
-    } ? TReturn : T[key] extends (...args: any[]) => infer TReturn ? TReturn : never;
-};
-type ObjectWatchOptionItem = {
-    handler: WatchCallback | string;
-} & WatchOptions;
-type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
-type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
-type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
-type ComponentProvideOptions = ObjectProvideOptions | Function;
-type ObjectProvideOptions = Record<string | symbol, unknown>;
-type ComponentInjectOptions = string[] | ObjectInjectOptions;
-type ObjectInjectOptions = Record<string | symbol, string | symbol | {
-    from?: string | symbol;
-    default?: unknown;
-}>;
-type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? {
-    [K in T[number]]?: unknown;
-} : T extends ObjectInjectOptions ? {
-    [K in keyof T]?: unknown;
-} : never;
-interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
-    compatConfig?: CompatConfig;
-    [key: string]: any;
-    data?: (this: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>, vm: CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, MethodOptions, Mixin, Extends>) => D;
-    computed?: C;
-    methods?: M;
-    watch?: ComponentWatchOptions;
-    provide?: Provide;
-    inject?: I | II[];
-    filters?: Record<string, Function>;
-    mixins?: Mixin[];
-    extends?: Extends;
-    beforeCreate?(): any;
-    created?(): any;
-    beforeMount?(): any;
-    mounted?(): any;
-    beforeUpdate?(): any;
-    updated?(): any;
-    activated?(): any;
-    deactivated?(): any;
-    /** @deprecated use `beforeUnmount` instead */
-    beforeDestroy?(): any;
-    beforeUnmount?(): any;
-    /** @deprecated use `unmounted` instead */
-    destroyed?(): any;
-    unmounted?(): any;
-    renderTracked?: DebuggerHook;
-    renderTriggered?: DebuggerHook;
-    errorCaptured?: ErrorCapturedHook;
-    /**
-     * runtime compile only
-     * @deprecated use `compilerOptions.delimiters` instead.
-     */
-    delimiters?: [string, string];
-    /**
-     * #3468
-     *
-     * type-only, used to assist Mixin's type inference,
-     * TypeScript will try to simplify the inferred `Mixin` type,
-     * with the `__differentiator`, TypeScript won't be able to combine different mixins,
-     * because the `__differentiator` will be different
-     */
-    __differentiator?: keyof D | keyof C | keyof M;
-}
-type MergedHook<T = () => void> = T | T[];
-type MergedComponentOptionsOverride = {
-    beforeCreate?: MergedHook;
-    created?: MergedHook;
-    beforeMount?: MergedHook;
-    mounted?: MergedHook;
-    beforeUpdate?: MergedHook;
-    updated?: MergedHook;
-    activated?: MergedHook;
-    deactivated?: MergedHook;
-    /** @deprecated use `beforeUnmount` instead */
-    beforeDestroy?: MergedHook;
-    beforeUnmount?: MergedHook;
-    /** @deprecated use `unmounted` instead */
-    destroyed?: MergedHook;
-    unmounted?: MergedHook;
-    renderTracked?: MergedHook<DebuggerHook>;
-    renderTriggered?: MergedHook<DebuggerHook>;
-    errorCaptured?: MergedHook<ErrorCapturedHook>;
-};
-type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
-type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
-    P: P;
-    B: B;
-    D: D;
-    C: C;
-    M: M;
-    Defaults: Defaults;
-};
-
-interface InjectionConstraint<T> {
-}
-type InjectionKey<T> = symbol & InjectionConstraint<T>;
-
-type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
-type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
-type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
-
-interface App<HostElement = any> {
-    version: string;
-    config: AppConfig;
-    use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: NoInfer<Options>): this;
-    use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this;
-    mixin(mixin: ComponentOptions): this;
-    component(name: string): Component | undefined;
-    component<T extends Component | DefineComponent>(name: string, component: T): this;
-    directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string): Directive<HostElement, Value, Modifiers, Arg> | undefined;
-    directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string, directive: Directive<HostElement, Value, Modifiers, Arg>): this;
-    mount(rootContainer: HostElement | string, 
-    /**
-     * @internal
-     */
-    isHydrate?: boolean, 
-    /**
-     * @internal
-     */
-    namespace?: boolean | ElementNamespace, 
-    /**
-     * @internal
-     */
-    vnode?: VNode): ComponentPublicInstance;
-    unmount(): void;
-    onUnmount(cb: () => void): void;
-    provide<T, K = InjectionKey<T> | string | number>(key: K, value: K extends InjectionKey<infer V> ? V : T): this;
-    /**
-     * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
-     * to variables provided via `app.provide()`.
-     *
-     * @param fn - function to run with the app as active instance
-     */
-    runWithContext<T>(fn: () => T): T;
-    _uid: number;
-    _component: ConcreteComponent;
-    _props: Data | null;
-    _container: HostElement | null;
-    _context: AppContext;
-    _instance: ComponentInternalInstance | null;
-    /**
-     * v2 compat only
-     */
-    filter?(name: string): Function | undefined;
-    filter?(name: string, filter: Function): this;
-}
-type OptionMergeFunction = (to: unknown, from: unknown) => any;
-interface AppConfig {
-    readonly isNativeTag: (tag: string) => boolean;
-    performance: boolean;
-    optionMergeStrategies: Record<string, OptionMergeFunction>;
-    globalProperties: ComponentCustomProperties & Record<string, any>;
-    errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
-    warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
-    /**
-     * Options to pass to `@vue/compiler-dom`.
-     * Only supported in runtime compiler build.
-     */
-    compilerOptions: RuntimeCompilerOptions;
-    /**
-     * @deprecated use config.compilerOptions.isCustomElement
-     */
-    isCustomElement?: (tag: string) => boolean;
-    /**
-     * TODO document for 3.5
-     * Enable warnings for computed getters that recursively trigger itself.
-     */
-    warnRecursiveComputed?: boolean;
-    /**
-     * Whether to throw unhandled errors in production.
-     * Default is `false` to avoid crashing on any error (and only logs it)
-     * But in some cases, e.g. SSR, throwing might be more desirable.
-     */
-    throwUnhandledErrorInProduction?: boolean;
-    /**
-     * Prefix for all useId() calls within this app
-     */
-    idPrefix?: string;
-}
-interface AppContext {
-    app: App;
-    config: AppConfig;
-    mixins: ComponentOptions[];
-    components: Record<string, Component>;
-    directives: Record<string, Directive>;
-    provides: Record<string | symbol, any>;
-}
-type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
-type ObjectPlugin<Options = any[]> = {
-    install: PluginInstallFunction<Options>;
-};
-type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
-type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>;
-
-type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
-interface TeleportProps {
-    to: string | RendererElement | null | undefined;
-    disabled?: boolean;
-    defer?: boolean;
-}
-declare const TeleportImpl: {
-    name: string;
-    __isTeleport: boolean;
-    process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
-    remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: boolean): void;
-    move: typeof moveTeleport;
-    hydrate: typeof hydrateTeleport;
-};
-declare enum TeleportMoveTypes {
-    TARGET_CHANGE = 0,
-    TOGGLE = 1,// enable / disable
-    REORDER = 2
-}
-declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
-declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector, insert, createText }, }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
-declare const Teleport: {
-    __isTeleport: true;
-    new (): {
-        $props: VNodeProps & TeleportProps;
-        $slots: {
-            default(): VNode[];
-        };
-    };
-};
-
-declare const Fragment: {
-    __isFragment: true;
-    new (): {
-        $props: VNodeProps;
-    };
-};
-declare const Text: unique symbol;
-declare const Comment: unique symbol;
-declare const Static: unique symbol;
-type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
-type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
-type VNodeNormalizedRefAtom = {
-    /**
-     * component instance
-     */
-    i: ComponentInternalInstance;
-    /**
-     * Actual ref
-     */
-    r: VNodeRef;
-    /**
-     * setup ref key
-     */
-    k?: string;
-    /**
-     * refInFor marker
-     */
-    f?: boolean;
-};
-type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
-type VNodeMountHook = (vnode: VNode) => void;
-type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
-type VNodeProps = {
-    key?: PropertyKey;
-    ref?: VNodeRef;
-    ref_for?: boolean;
-    ref_key?: string;
-    onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[];
-    onVnodeMounted?: VNodeMountHook | VNodeMountHook[];
-    onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[];
-    onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[];
-    onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
-    onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
-};
-type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
-type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
-type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
-type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
-interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
-    [key: string]: any;
-}> {
-    type: VNodeTypes;
-    props: (VNodeProps & ExtraProps) | null;
-    key: PropertyKey | null;
-    ref: VNodeNormalizedRef | null;
-    /**
-     * SFC only. This is assigned on vnode creation using currentScopeId
-     * which is set alongside currentRenderingInstance.
-     */
-    scopeId: string | null;
-    children: VNodeNormalizedChildren;
-    component: ComponentInternalInstance | null;
-    dirs: DirectiveBinding[] | null;
-    transition: TransitionHooks<HostElement> | null;
-    el: HostNode | null;
-    placeholder: HostNode | null;
-    anchor: HostNode | null;
-    target: HostElement | null;
-    targetStart: HostNode | null;
-    targetAnchor: HostNode | null;
-    suspense: SuspenseBoundary | null;
-    shapeFlag: number;
-    patchFlag: number;
-    appContext: AppContext | null;
-}
-
-type Data = Record<string, unknown>;
-/**
- * For extending allowed non-declared props on components in TSX
- */
-interface ComponentCustomProps {
-}
-/**
- * For globally defined Directives
- * Here is an example of adding a directive `VTooltip` as global directive:
- *
- * @example
- * ```ts
- * import VTooltip from 'v-tooltip'
- *
- * declare module '@vue/runtime-core' {
- *   interface GlobalDirectives {
- *     VTooltip
- *   }
- * }
- * ```
- */
-interface GlobalDirectives {
-}
-/**
- * For globally defined Components
- * Here is an example of adding a component `RouterView` as global component:
- *
- * @example
- * ```ts
- * import { RouterView } from 'vue-router'
- *
- * declare module '@vue/runtime-core' {
- *   interface GlobalComponents {
- *     RouterView
- *   }
- * }
- * ```
- */
-interface GlobalComponents {
-    Teleport: DefineComponent<TeleportProps>;
-    Suspense: DefineComponent<SuspenseProps>;
-    KeepAlive: DefineComponent<KeepAliveProps>;
-    BaseTransition: DefineComponent<BaseTransitionProps>;
-}
-/**
- * Default allowed non-declared props on component in TSX
- */
-interface AllowedComponentProps {
-    class?: unknown;
-    style?: unknown;
-}
-interface ComponentInternalOptions {
-    /**
-     * Compat build only, for bailing out of certain compatibility behavior
-     */
-    __isBuiltIn?: boolean;
-    /**
-     * This one should be exposed so that devtools can make use of it
-     */
-    __file?: string;
-    /**
-     * name inferred from filename
-     */
-    __name?: string;
-}
-interface FunctionalComponent<P = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
-    (props: P & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
-    props?: ComponentPropsOptions<P>;
-    emits?: EE | (keyof EE)[];
-    slots?: IfAny<S, Slots, SlotsType<S>>;
-    inheritAttrs?: boolean;
-    displayName?: string;
-    compatConfig?: CompatConfig;
-}
-/**
- * Concrete component type matches its actual value: it's either an options
- * object, or a function. Use this where the code expects to work with actual
- * values, e.g. checking if its a function or not. This is mostly for internal
- * implementation code.
- */
-type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props, RawBindings, D, C, M> | FunctionalComponent<Props, E, S>;
-/**
- * A type used in public APIs where a component type is expected.
- * The constructor type is an artificial type returned by defineComponent().
- */
-type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
-
-type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
-    attrs: Data;
-    slots: UnwrapSlotsType<S>;
-    emit: EmitFn<E>;
-    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
-} : never;
-/**
- * We expose a subset of properties on the internal instance as they are
- * useful for advanced external libraries and tools.
- */
-interface ComponentInternalInstance {
-    uid: number;
-    type: ConcreteComponent;
-    parent: ComponentInternalInstance | null;
-    root: ComponentInternalInstance;
-    appContext: AppContext;
-    /**
-     * Vnode representing this component in its parent's vdom tree
-     */
-    vnode: VNode;
-    /**
-     * Root vnode of this component's own vdom tree
-     */
-    subTree: VNode;
-    /**
-     * Render effect instance
-     */
-    effect: ReactiveEffect;
-    /**
-     * Force update render effect
-     */
-    update: () => void;
+declare abstract class ADataProvider<TRow = TDataRow> {
+    idKey: string;
+    pageData: TRow[];
+    protected _rowCount: number;
+    get rowCount(): number;
+    set rowCount(val: number);
+    protected _loading: boolean;
+    get loading(): boolean;
+    set loading(val: boolean);
+    protected _initialLoad: boolean;
+    get initialLoad(): boolean;
+    set initialLoad(val: boolean);
+    protected _error: any;
+    get error(): any;
+    set error(val: any);
+    SSR: boolean;
+    deduplicate: boolean;
+    context: any;
+    urlPageParam: string;
+    protected _selectedRows: TRow[];
+    get selectedRows(): TRow[];
+    set selectedRows(val: TRow[]);
+    protected _selectAll: boolean;
+    get selectAll(): boolean;
+    set selectAll(val: boolean);
+    protected _currentPage: number;
+    protected _pageSize: number;
+    protected _filter: IDataFilter | null;
+    protected _sortList: IDataSort[];
+    get currentPage(): number;
+    set currentPage(page: number);
+    get pageSize(): number;
+    set pageSize(size: number);
+    get filter(): IDataFilter | null;
+    set filter(f: IDataFilter | null);
+    get sortList(): IDataSort[];
+    set sortList(s: IDataSort[]);
+    private _listeners;
+    private _debouncedFilterLoad;
+    private _debouncedSortLoad;
+    constructor(options?: IDataProviderOptions);
+    private _batchDepth;
+    private _pendingNotify;
+    private _isNotifying;
     /**
-     * Render effect job to be passed to scheduler (checks if dirty)
+     * Batches multiple state updates so notify() fires exactly once upon completion.
      */
-    job: SchedulerJob;
-    proxy: ComponentPublicInstance | null;
-    exposed: Record<string, any> | null;
-    exposeProxy: Record<string, any> | null;
-    data: Data;
-    props: Data;
-    attrs: Data;
-    slots: InternalSlots;
-    refs: Data;
-    emit: EmitFn;
-    isMounted: boolean;
-    isUnmounted: boolean;
-    isDeactivated: boolean;
-}
-interface WatchEffectOptions extends DebuggerOptions {
-    flush?: 'pre' | 'post' | 'sync';
-}
-interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
-    immediate?: Immediate;
-    deep?: boolean | number;
-    once?: boolean;
-}
-
-declare module '@vue/reactivity' {
-    interface RefUnwrapBailTypes {
-        runtimeCoreBailTypes: VNode | {
-            $: ComponentInternalInstance;
-        };
-    }
-}
-// Note: this file is auto concatenated to the end of the bundled d.ts during
-// build.
-
-declare module '@vue/runtime-core' {
-  export interface GlobalComponents {
-    Teleport: DefineComponent<TeleportProps>
-    Suspense: DefineComponent<SuspenseProps>
-    KeepAlive: DefineComponent<KeepAliveProps>
-    BaseTransition: DefineComponent<BaseTransitionProps>
-  }
-}
-
-// Note: this file is auto concatenated to the end of the bundled d.ts during
-// build.
-type _defineProps = typeof defineProps
-type _defineEmits = typeof defineEmits
-type _defineExpose = typeof defineExpose
-type _defineOptions = typeof defineOptions
-type _defineSlots = typeof defineSlots
-type _defineModel = typeof defineModel
-type _withDefaults = typeof withDefaults
-
-declare global {
-  const defineProps: _defineProps
-  const defineEmits: _defineEmits
-  const defineExpose: _defineExpose
-  const defineOptions: _defineOptions
-  const defineSlots: _defineSlots
-  const defineModel: _defineModel
-  const withDefaults: _withDefaults
-}
-
-declare const TRANSITION = "transition";
-declare const ANIMATION = "animation";
-type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
-interface TransitionProps extends BaseTransitionProps<Element> {
-    name?: string;
-    type?: AnimationTypes;
-    css?: boolean;
-    duration?: number | {
-        enter: number;
-        leave: number;
+    batchUpdates<R>(fn: () => R): R;
+    subscribe(listener: TDataProviderListener<this>): TUnsubscribe;
+    notify(): void;
+    getState(): {
+        pageData: TRow[];
+        rowCount: number;
+        currentPage: number;
+        pageSize: number;
+        loading: boolean;
+        initialLoad: boolean;
+        error: any;
+        filter: IDataFilter | null;
+        sortList: IDataSort[];
+        selectedRows: TRow[];
+        selectAll: boolean;
     };
-    enterFromClass?: string;
-    enterActiveClass?: string;
-    enterToClass?: string;
-    appearFromClass?: string;
-    appearActiveClass?: string;
-    appearToClass?: string;
-    leaveFromClass?: string;
-    leaveActiveClass?: string;
-    leaveToClass?: string;
-}
-
-type TransitionGroupProps = Omit<TransitionProps, 'mode'> & {
-    tag?: string;
-    moveClass?: string;
-};
-
-declare const vShowOriginalDisplay: unique symbol;
-declare const vShowHidden: unique symbol;
-interface VShowElement extends HTMLElement {
-    [vShowOriginalDisplay]: string;
-    [vShowHidden]: boolean;
-}
-declare const vShow: ObjectDirective<VShowElement> & {
-    name: 'show';
-};
-
-declare const systemModifiers: readonly ["ctrl", "shift", "alt", "meta"];
-type SystemModifiers = (typeof systemModifiers)[number];
-type CompatModifiers = keyof typeof keyNames;
-type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
-type ModifierGuards = 'shift' | 'ctrl' | 'alt' | 'meta' | 'left' | 'right' | 'stop' | 'prevent' | 'self' | 'middle' | 'exact';
-declare const keyNames: Record<'esc' | 'space' | 'up' | 'left' | 'right' | 'down' | 'delete', string>;
-type VOnDirective = Directive<any, any, VOnModifiers>;
-
-type AssignerFn = (value: any) => void;
-declare const assignKey: unique symbol;
-type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
-    [assignKey]: AssignerFn;
-    _assigning?: boolean;
-}, any, Modifiers>;
-declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, 'trim' | 'number' | 'lazy'>;
-declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
-declare const vModelRadio: ModelDirective<HTMLInputElement>;
-declare const vModelSelect: ModelDirective<HTMLSelectElement, 'number'>;
-declare const vModelDynamic: ObjectDirective<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
-type VModelDirective = typeof vModelText | typeof vModelCheckbox | typeof vModelSelect | typeof vModelRadio | typeof vModelDynamic;
-
-/**
- * This is a stub implementation to prevent the need to use dom types.
- *
- * To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
- */
-type DomType<T> = typeof globalThis extends {
-    window: unknown;
-} ? T : never;
-declare module '@vue/reactivity' {
-    interface RefUnwrapBailTypes {
-        runtimeDOMBailTypes: DomType<Node | Window>;
-    }
-}
-declare module '@vue/runtime-core' {
-    interface GlobalComponents {
-        Transition: DefineComponent<TransitionProps>;
-        TransitionGroup: DefineComponent<TransitionGroupProps>;
-    }
-    interface GlobalDirectives {
-        vShow: typeof vShow;
-        vOn: VOnDirective;
-        vBind: VModelDirective;
-        vIf: Directive<any, boolean>;
-        vOnce: Directive;
-        vSlot: Directive;
-    }
-}
-
-declare abstract class ADataProvider {
-    filter: Ref<IDataFilter | null>;
-    sortList: Ref<IDataSort[]>;
-    currentPage: Ref<number>;
-    pageSize: Ref<number>;
-    pageData: Ref<TDataRow[]>;
-    rowCount: Ref<number>;
-    loading: Ref<Boolean>;
-    SSR: Ref<Boolean>;
-    deduplicate: Ref<Boolean>;
-    nuxtApp: any;
-    urlPageParam: Ref<string>;
-    selectedRows: Ref<any[]>;
-    selectAll: Ref<boolean>;
-    constructor(options?: IDataProviderOptions);
     setFilter(filter: IDataFilter | null): void;
-    setSortList(sortList: IDataSort[]): void;
+    setSortList(sortList: IDataSort[], immediate?: boolean): void;
     setCurrentPage(currentPage: number): void;
     setPageSize(pageSize: number): void;
-    abstract loadPageData(): void;
+    setSelectedRows(rows: TRow[]): void;
+    setSelectAll(val: boolean): void;
+    abstract loadPageData(options?: {
+        disableCache?: boolean;
+        signal?: AbortSignal;
+    }): void | Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
+    cancelPending(): void;
 }
 
-declare class CFlatClientDataProvider extends ADataProvider {
-    allData: Ref<TDataRow[]>;
-    filteredData: Ref<TDataRow[]>;
+declare class CFlatClientDataProvider<TRow = TDataRow> extends ADataProvider<TRow> {
+    allData: TRow[];
+    filteredData: TRow[];
     constructor(options?: IDataProviderOptions);
-    setData(data: TDataRow[]): void;
+    setData(data: TRow[]): void;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
     loadPageData(): Promise<void>;
-    refreshData(): void;
 }
 
 declare abstract class ACacheProvider {
     constructor();
-    abstract getKeyList(nuxtApp?: any): Array<string> | Promise<Array<string>>;
-    abstract get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    abstract set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    abstract remove(key: string, nuxtApp?: any): Promise<void>;
-    abstract removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    abstract getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    abstract getKeyList(context?: any): Array<string> | Promise<Array<string>>;
+    abstract get<T>(key: string, context?: any): Promise<T | null>;
+    abstract set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    abstract remove(key: string, context?: any): Promise<void>;
+    abstract removeByPrefix(prefix: string, context?: any): Promise<void>;
+    abstract getRemainingTime(key: string, context?: any): Promise<number | null>;
     abstract cleanupExpired(): Promise<void>;
 }
 
 declare class RequestProvider {
     cacheProvider: ACacheProvider | null;
+    cacheStrategy?: ECacheStrategy;
     cacheLifetime: number | null;
     deduplicate: boolean;
     cacheKey: string;
+    /** Registry tags — set via useRequestProvider() or manually */
+    tags: string[];
+    /** If true, non-GET requests are enqueued instead of sent immediately */
+    queue: boolean;
     private static requestQueue;
     private static executing;
     private static requestsInFlight;
+    private lastUrl?;
+    private lastOptions?;
+    private dataReceivedCallback?;
     constructor(provider?: ACacheProvider | ECacheStrategy, lifetime?: number, deduplicate?: boolean);
     setCacheProvider(provider?: ACacheProvider | ECacheStrategy): void;
     setCacheLifetime(lifetime: number): void;
     setDeduplicate(deduplicate: boolean): void;
+    onDataReceived(callback: (data: any, generation?: number) => void): void;
+    private invokeDataReceivedCallback;
+    hasLastUrl(): boolean;
+    refresh(hardRefresh?: boolean): Promise<any>;
+    private resolveContext;
+    private getInFlightMap;
     private getUniqueKey;
     registerRequest<T>(url: string, options?: IRequestOptions): Promise<T>;
     static executeAll(): void;
+    private isSameOriginUrl;
     request<T>(url: string, options?: IRequestOptions): Promise<T>;
 }
 
 declare abstract class AAPIDataProvider {
-    apiUrl: Ref<string>;
-    cacheStrategy: Ref<ECacheStrategy | null>;
-    cacheLifetime: Ref<number>;
+    apiUrl: string;
+    cacheStrategy: ECacheStrategy | null;
+    cacheLifetime: number;
     requestProvider: RequestProvider;
-    refreshOnMutation: Ref<boolean | undefined>;
+    refreshOnMutation: boolean | undefined;
     constructor(options?: IDataProviderOptions);
     abstract setAPIUrl(url: string): void;
     abstract create(item: any): Promise<void>;
@@ -1590,16 +376,17 @@ declare abstract class AAPIDataProvider {
     abstract delete(items: any[]): Promise<void>;
 }
 
-declare class CAPIFlatClientDataProvider extends CFlatClientDataProvider implements AAPIDataProvider {
-    apiUrl: Ref<string>;
-    contextKey: Ref<string>;
-    initialLoad: Ref<boolean>;
+declare class CAPIFlatClientDataProvider<TRow = TDataRow> extends CFlatClientDataProvider<TRow> implements AAPIDataProvider {
+    apiUrl: string;
+    contextKey: string;
     requestProvider: RequestProvider;
-    cacheStrategy: Ref<ECacheStrategy | null>;
-    cacheLifetime: Ref<number>;
-    refreshOnMutation: Ref<boolean | undefined>;
+    cacheStrategy: ECacheStrategy | null;
+    cacheLifetime: number;
+    refreshOnMutation: boolean | undefined;
     constructor(options?: IDataProviderOptions);
     setContextKey(key: string): void;
+    setCacheStrategy(strategy: ECacheStrategy): void;
+    setCacheLifetime(lifetime: number): void;
     refreshData(options?: {
         disableCache?: boolean;
     }): Promise<void>;
@@ -1609,89 +396,97 @@ declare class CAPIFlatClientDataProvider extends CFlatClientDataProvider impleme
     delete(items: any[]): Promise<void>;
 }
 
-declare class CFlatServerDataProvider extends ADataProvider {
-    pageDataHandler: Ref<TPageDataHandler>;
-    contextKey: Ref<string>;
-    initialLoad: Ref<boolean>;
+declare class CFlatServerDataProvider<TRow = TDataRow> extends ADataProvider<TRow> {
+    pageDataHandler: TPageDataHandler<TRow>;
+    contextKey: string;
+    private latestRequestId;
+    private abortController;
     constructor(options?: IDataProviderOptions);
     setContextKey(key: string): void;
-    setPageDataHandler(handler: TPageDataHandler): Promise<void>;
+    setPageDataHandler(handler: TPageDataHandler<TRow>): Promise<void>;
     loadPageData(options?: {
         disableCache?: boolean;
+        signal?: AbortSignal;
     }): Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
 }
 
-declare class CAPIFlatServerDataProvider extends CFlatServerDataProvider implements AAPIDataProvider {
-    apiUrl: Ref<string>;
+declare class CAPIFlatServerDataProvider<TRow = TDataRow> extends CFlatServerDataProvider<TRow> implements AAPIDataProvider {
+    apiUrl: string;
     requestProvider: RequestProvider;
-    cacheStrategy: Ref<ECacheStrategy | null>;
-    cacheLifetime: Ref<number>;
-    refreshOnMutation: Ref<boolean | undefined>;
+    cacheStrategy: ECacheStrategy | null;
+    cacheLifetime: number;
+    refreshOnMutation: boolean | undefined;
+    /** Incremented on every new request; stale onDataReceived callbacks are discarded. */
+    private _requestGeneration;
     constructor(options?: IDataProviderOptions);
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
     setAPIUrl(url: string): Promise<void>;
     delete(items: any[]): Promise<void>;
+    create(item: any): Promise<void>;
+    update(item: any): Promise<void>;
 }
 
-declare class CTreeClientDataProvider extends CFlatClientDataProvider {
+declare class CTreeClientDataProvider<TRow extends TDataRow = TDataRow> extends CFlatClientDataProvider<TRow> implements ITreeDataProvider<TRow> {
     parentKey: string;
     idKey: string;
     expandedByDefault: boolean;
     paginateBy: TreePaginationMode;
-    expandedNodes: Ref<Set<string | number>>;
-    private _staticNodes;
-    private _nodeMap;
-    private _sortedNodeIds;
+    expandedNodes: Set<string | number>;
+    private _staticNodesCache;
+    private _nodeMapCache;
+    private _sortedNodeIdsCache;
+    invalidateStaticCache(): void;
+    private get _staticNodes();
+    private get _nodeMap();
+    private get _sortedNodeIds();
     constructor(options?: ITreeDataProviderOptions);
+    setData(data: TRow[]): void;
     private buildStaticNodes;
     private computeSortedIds;
-    private updatePageData;
     private isNodeVisible;
     private paginateNodes;
+    private updatePageData;
     loadPageData(): Promise<void>;
-    get treeNodes(): ITreeNode[];
-    get visibleRows(): ITreeNode[];
+    get treeNodes(): ITreeNode<TRow>[];
+    get visibleRows(): ITreeNode<TRow>[];
+    getAllNodes(): ITreeNode<TRow>[];
+    getFlatNodes(): ITreeNode<TRow>[];
     toggleNode(nodeId: string | number): void;
     expand(nodeId: string | number): void;
     collapse(nodeId: string | number): void;
+    expandNode(nodeId: string | number): void;
+    collapseNode(nodeId: string | number): void;
     expandAll(): void;
     collapseAll(): void;
-    getNode(nodeId: string | number): ITreeNode | undefined;
-    getChildren(nodeId: string | number): ITreeNode[];
-    getParent(nodeId: string | number): ITreeNode | undefined;
+    getNode(nodeId: string | number): ITreeNode<TRow> | undefined;
+    getChildren(nodeId: string | number): ITreeNode<TRow>[];
+    getParent(nodeId: string | number): ITreeNode<TRow> | undefined;
 }
 
-declare class CAPITreeClientDataProvider extends CTreeClientDataProvider implements AAPIDataProvider {
-    apiUrl: Ref<string>;
-    contextKey: Ref<string>;
-    initialLoad: Ref<boolean>;
+declare class CAPITreeClientDataProvider<TRow extends TDataRow = TDataRow> extends CTreeClientDataProvider<TRow> implements AAPIDataProvider {
+    apiUrl: string;
+    contextKey: string;
     requestProvider: RequestProvider;
-    cacheStrategy: Ref<ECacheStrategy | null>;
-    cacheLifetime: Ref<number>;
-    refreshOnMutation: Ref<boolean | undefined>;
+    cacheStrategy: ECacheStrategy | null;
+    cacheLifetime: number;
+    refreshOnMutation: boolean | undefined;
     constructor(options?: ITreeDataProviderOptions);
     setContextKey(key: string): void;
+    refresh(hardRefresh?: boolean): Promise<void>;
     refreshData(options?: {
         disableCache?: boolean;
     }): Promise<void>;
+    private _initialFetch;
     setAPIUrl(url: string): Promise<void>;
     create(item: any): Promise<void>;
     update(item: any): Promise<void>;
     delete(items: any[]): Promise<void>;
 }
 
-/**
- * Tree-specific page data handler that includes tree parameters
- * Server handles tree building, visibility, and pagination
- */
-type TTreePageDataHandler = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], treeParams: {
-    expandedNodes: (string | number)[];
-    parentKey: string;
-    idKey: string;
-    paginateBy: TreePaginationMode;
-    expandedByDefault: boolean;
-}, options?: {
-    disableCache?: boolean;
-}) => IDataResult | Promise<IDataResult>;
 /**
  * Server-side Tree Data Provider
  *
@@ -1701,25 +496,28 @@ type TTreePageDataHandler = (currentPage: number, pageSize: number, filter: IDat
  * - Server returns already-paginated visible rows with __treeNode metadata
  * - No allData - server handles everything
  */
-declare class CTreeServerDataProvider extends ADataProvider {
+declare class CTreeServerDataProvider<TRow = TDataRow> extends ADataProvider<TRow> implements ITreeDataProvider<TRow> {
     parentKey: string;
     idKey: string;
     expandedByDefault: boolean;
     paginateBy: TreePaginationMode;
-    expandedNodes: Ref<Set<string | number>>;
-    pageDataHandler: Ref<TTreePageDataHandler | null>;
-    contextKey: Ref<string>;
-    initialLoad: Ref<boolean>;
+    expandedNodes: Set<string | number>;
+    pageDataHandler: TTreePageDataHandler<TRow> | null;
+    contextKey: string;
     constructor(options?: ITreeDataProviderOptions);
     setContextKey(key: string): void;
-    setPageDataHandler(handler: TTreePageDataHandler): Promise<void>;
+    setPageDataHandler(handler: TTreePageDataHandler<TRow>): Promise<void>;
+    private latestRequestId;
+    private abortController;
     /**
      * Load page data from server
      * Server handles tree building, visibility, and pagination
      */
     loadPageData(options?: {
         disableCache?: boolean;
+        signal?: AbortSignal;
     }): Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
     toggleNode(nodeId: string | number): void;
     expand(nodeId: string | number): void;
     collapse(nodeId: string | number): void;
@@ -1735,30 +533,110 @@ declare class CTreeServerDataProvider extends ADataProvider {
  * - Request management (caching, deduplication)
  * - Automatic tree parameter serialization in query
  */
-declare class CAPITreeServerDataProvider extends CTreeServerDataProvider implements AAPIDataProvider {
-    apiUrl: Ref<string>;
+declare class CAPITreeServerDataProvider<TRow = TDataRow> extends CTreeServerDataProvider<TRow> implements AAPIDataProvider {
+    apiUrl: string;
     requestProvider: RequestProvider;
-    cacheStrategy: Ref<ECacheStrategy | null>;
-    cacheLifetime: Ref<number>;
-    refreshOnMutation: Ref<boolean | undefined>;
+    cacheStrategy: ECacheStrategy | null;
+    cacheLifetime: number;
+    refreshOnMutation: boolean | undefined;
+    /** Incremented on every new request; stale onDataReceived callbacks are discarded. */
+    private _requestGeneration;
     constructor(options?: ITreeDataProviderOptions);
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
     setAPIUrl(url: string): Promise<void>;
     delete(items: any[]): Promise<void>;
+    create(item: any): Promise<void>;
+    update(item: any): Promise<void>;
+}
+
+/**
+ * KatluxIndexedDB
+ *
+ * Shared IndexedDB connection singleton for the entire @katlux/providers library.
+ * All IndexedDB consumers (CIndexedDBCache, RequestQueue) use this single connection,
+ * ensuring there is one database, one version number, and no versionchange conflicts.
+ *
+ * KatluxDB stores:
+ *   cache       — used by CIndexedDBCache
+ *   queue       — used by RequestQueue (pending operations)
+ *   dead_letter — used by RequestQueue (permanently failed operations)
+ */
+type TKatluxStore = 'cache' | 'queue' | 'dead_letter' | (string & {});
+declare class KatluxIndexedDB {
+    private static db;
+    private static openPromise;
+    private static currentVersion;
+    private static customStores;
+    static readonly DB_NAME = "KatluxDB";
+    static get DB_VERSION(): number;
+    /**
+     * Opens (or returns the existing) shared IDBDatabase connection.
+     * Safe to call multiple times — always resolves to the same instance.
+     */
+    static open(): Promise<IDBDatabase>;
+    private static upgradeToVersion;
+    /**
+     * Dynamically ensures that an object store exists in the database.
+     * If not present, performs a database version bump and creates the store.
+     */
+    static ensureStore(storeName: string): Promise<IDBDatabase>;
+    /**
+     * Returns a transaction-bound object store.
+     * Convenience wrapper used by CIndexedDBCache, QueueStorage adapters, etc.
+     */
+    static getStore(storeName: TKatluxStore, mode: IDBTransactionMode): Promise<IDBObjectStore>;
+    /**
+     * For testing only — resets the singleton so tests can start fresh.
+     */
+    static _reset(): void;
 }
 
+type CacheDriverLoader = () => Promise<{
+    getInstance: () => ACacheProvider;
+}>;
 declare class CacheProviderFactory {
-    static getProvider(strategy: ECacheStrategy): ACacheProvider | null;
+    private static instanceCache;
+    private static customDrivers;
+    private static readonly defaultLoaders;
+    /**
+     * Register a custom or pre-loaded cache provider driver
+     */
+    static registerDriver(strategy: string, loaderOrClass: CacheDriverLoader | {
+        getInstance: () => ACacheProvider;
+    }): void;
+    /**
+     * Asynchronously load and return the cache provider singleton for a strategy.
+     */
+    static getProvider(strategy: ECacheStrategy | string): Promise<ACacheProvider | null>;
+    /**
+     * Synchronously returns the cache provider if it was already loaded/instantiated,
+     * or undefined otherwise.
+     */
+    static getProviderSync(strategy: ECacheStrategy | string): ACacheProvider | undefined;
+    /**
+     * Clear cached singleton instances (useful for testing or cache resets)
+     */
+    static clearInstances(): void;
 }
 
 declare class CSessionCache extends ACacheProvider {
     private static instance;
     static getInstance(): CSessionCache;
-    private static get storage();
+    static get storage(): Map<string, Map<string, ICacheEntry<any>>>;
     static getSnapshot(): Map<string, Map<string, ICacheEntry<any>>>;
+    static MAX_SERVER_SESSIONS: number;
+    /**
+     * Purges expired entries across all server sessions synchronously when the storage
+     * exceeds MAX_SERVER_SESSIONS. Avoids persistent background setInterval timers on Node.js/SSR.
+     */
+    static purgeExpiredServerSessions(): void;
     private sessionIdCache;
     private sessionId;
     private readonly SESSION_ID_KEY;
-    private constructor();
+    constructor();
     /**
      * Generate a UUID v4 sessionId
      */
@@ -1767,12 +645,12 @@ declare class CSessionCache extends ACacheProvider {
      * Get or create sessionId
      */
     private getSessionId;
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
     cleanupExpired(): Promise<void>;
 }
 
@@ -1780,12 +658,16 @@ declare class CCookieCache extends ACacheProvider {
     private static instance;
     static getInstance(): CCookieCache;
     type: string;
-    private constructor();
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    constructor();
+    private getCookieKey;
+    private parseKeyFromCookieName;
+    private isClient;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
     cleanupExpired(): Promise<void>;
 }
 
@@ -1795,33 +677,29 @@ declare class CLocalStorageCache extends ACacheProvider {
     type: string;
     private constructor();
     private _hydrateFromPayload;
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
     cleanupExpired(): Promise<void>;
 }
 
 declare class CIndexedDBCache extends ACacheProvider {
     private static instance;
-    static getInstance(): CIndexedDBCache;
-    private dbName;
-    private storeName;
-    private version;
-    private dbPromise;
-    setStore(storeName?: string): void;
-    private constructor();
+    private static instances;
+    readonly storeName: string;
+    static getInstance(storeName?: string): CIndexedDBCache;
+    constructor(storeName?: string);
     private _hydrateFromPayload;
-    private openDB;
     private getStore;
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
     cleanupExpired(): Promise<void>;
 }
 
@@ -1832,12 +710,13 @@ declare class CMemoryCache extends ACacheProvider {
     static getInstance(): CMemoryCache;
     private constructor();
     private _hydrateFromPayload;
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    private isServer;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
     cleanupExpired(): Promise<void>;
 }
 
@@ -1846,16 +725,326 @@ declare class CApplicationCache extends ACacheProvider {
     private static _storage;
     private static get storage();
     static getInstance(): CApplicationCache;
+    static readonly MAX_ENTRIES = 10000;
     static getSnapshot(): Map<string, ICacheEntry<any>>;
+    /**
+     * Purges expired entries when storage size reaches MAX_ENTRIES watermark.
+     * Avoids persistent background setInterval timers on Node.js/SSR.
+     */
+    static purgeExpiredEntries(): void;
+    /**
+     * Clears all cached entries (used for test isolation).
+     */
+    static clear(): void;
     private constructor();
-    getKeyList(nuxtApp?: any): Promise<Array<string>>;
-    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
-    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
-    remove(key: string, nuxtApp?: any): Promise<void>;
-    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
-    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
-    cleanupExpired(): Promise<void>;
+    private isServer;
+    getKeyList(context?: any): Promise<Array<string>>;
+    get<T>(key: string, context?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, context?: any): Promise<void>;
+    remove(key: string, context?: any): Promise<void>;
+    removeByPrefix(prefix: string, context?: any): Promise<void>;
+    getRemainingTime(key: string, context?: any): Promise<number | null>;
+    cleanupExpired(context?: any): Promise<void>;
+}
+
+interface IRegistryEntry {
+    provider: RequestProvider;
+    tags: string[];
+}
+/**
+ * RequestProviderRegistry
+ *
+ * Static singleton registry that maps RequestProvider instances to string tags.
+ * When a mutation completes on any tagged provider, the registry automatically
+ * calls refresh(true) on all GET-capable providers sharing any of those tags.
+ *
+ * Framework-agnostic — no Vue imports. Works in any JS environment.
+ *
+ * Usage:
+ *   // Register (or use the useRequestProvider() Vue composable for auto-lifecycle)
+ *   RequestProviderRegistry.register(myProvider, ['invoices', 'sales'])
+ *
+ *   // Unregister manually (or automatically via useRequestProvider onUnmounted)
+ *   RequestProviderRegistry.unregister(myProvider)
+ *
+ *   // Manual targeted refresh
+ *   await RequestProviderRegistry.refreshByTag('invoices', true)
+ *
+ *   // Called internally by RequestProvider after a successful non-GET request
+ *   await RequestProviderRegistry.notifyMutation(['invoices'])
+ */
+declare class RequestProviderRegistry {
+    private static entries;
+    /**
+     * Register a provider with one or more tags.
+     * If the provider is already registered, its tags are updated.
+     * In SSR (Node.js), registration is skipped to prevent process-global memory leaks
+     * and cross-user multi-tenant invalidation.
+     */
+    static register(provider: RequestProvider, tags: string[]): void;
+    /**
+     * Unregister a provider from the registry.
+     * After this, the provider will no longer receive auto-refresh signals.
+     */
+    static unregister(provider: RequestProvider): void;
+    /**
+     * Manually refresh all providers matching a specific tag.
+     */
+    static refreshByTag(tag: string, hardRefresh?: boolean): Promise<void>;
+    /**
+     * Called internally by RequestProvider (after non-GET success) and by
+     * RequestQueue (after flush with at least one success).
+     *
+     * Finds all registered providers sharing any of the succeeded tags and
+     * calls refresh(true) once per unique provider (deduplication built in).
+     */
+    static notifyMutation(succeededTags: string[]): Promise<void>;
+    /**
+     * Returns a copy of all registry entries.
+     * Useful for debugging and testing.
+     */
+    static getEntries(): IRegistryEntry[];
+    /**
+     * Clears the entire registry.
+     * Use on app teardown (e.g., logout) or in tests.
+     */
+    static clear(): void;
 }
 
-export { AAPIDataProvider, ADataProvider, CAPIFlatClientDataProvider, CAPIFlatServerDataProvider, CAPITreeClientDataProvider, CAPITreeServerDataProvider, CApplicationCache, CCookieCache, CFlatClientDataProvider, CFlatServerDataProvider, CIndexedDBCache, CLocalStorageCache, CMemoryCache, CSessionCache, CTreeClientDataProvider, CTreeServerDataProvider, CacheProviderFactory, ECacheStrategy, EDataFilterOperator, RequestProvider };
-export type { ICacheEntry, IDataFilter, IDataProviderOptions, IDataResult, IDataSort, IKDatatableAction, IRequestOptions, ITreeDataProviderOptions, ITreeNode, ITreeNodeStatic, KProductItemData, KProductRowAction, TDataRow, TPageDataHandler, TreePaginationMode };
+declare const SENSITIVE_HEADER_KEYS: string[];
+/**
+ * RequestQueue
+ *
+ * Static class that manages the offline mutation queue and dead-letter store.
+ * Pure framework-agnostic TypeScript with subscription notifications.
+ *
+ * Design rules:
+ *  - Stop-on-first-failure: flush halts when any item fails
+ *  - No internal retry: the queue is the retry mechanism (items persist until flushed)
+ *  - Partial refresh: registry refresh fires for succeeded tags only
+ *  - Dead-letter is final: Katlux never auto-retries — app decides via retryOne() or discard()
+ *
+ * Usage:
+ *   RequestQueue.setStorageBackend(EQueueStorage.IndexedDB)
+ *   await RequestQueue.init()  // call once at app startup
+ *
+ *   // Hooks (set in app setup, not in components)
+ *   RequestQueue.onDeadLetter((item, err) => toast.error(`Failed: ${item.label}`))
+ *   RequestQueue.onFlushComplete((tags) => console.log('Synced tags:', tags))
+ *   RequestQueue.onNetworkError((item) => toast.warn('Offline — will retry when back online'))
+ *
+ *   // Flush when back online
+ *   window.addEventListener('online', () => RequestQueue.flushAll())
+ */
+declare class RequestQueue {
+    static queue: IQueuedOperation[];
+    static deadLetterQueue: IDeadLetterItem[];
+    static isFlushing: boolean;
+    private static MAX_PAYLOAD_SIZE_BYTES;
+    private static MAX_QUEUE_SIZE;
+    private static MAX_DEAD_LETTER_SIZE;
+    static setMaxPayloadSize(bytes: number): void;
+    static setMaxQueueSize(limit: number): void;
+    static setMaxDeadLetterSize(limit: number): void;
+    /**
+     * Strips sensitive headers (e.g., authorization, cookie, x-csrf-token) before persisting
+     * request options to persistent storage (IndexedDB / LocalStorage).
+     * Sensitive credentials must never be stored in plaintext in browser storage, and are
+     * instead regenerated dynamically at execution time.
+     */
+    private static sanitizeOptions;
+    private static _subscribers;
+    static subscribe(listener: () => void): () => void;
+    static notify(): void;
+    private static adapter;
+    private static initialized;
+    private static initPromise;
+    private static _onDeadLetter;
+    private static _onFlushComplete;
+    private static _onNetworkError;
+    /**
+     * Load persisted queue from storage into state.
+     * Call once at app startup, before any flush or enqueue operations.
+     */
+    static init(): Promise<void>;
+    /**
+     * Set the storage backend. Call before init().
+     * Defaults to IndexedDB with fallback to LocalStorage → Memory.
+     */
+    static setStorageBackend(backend: EQueueStorage): void;
+    static onDeadLetter(cb: (item: IDeadLetterItem, error: Error) => void): void;
+    static onFlushComplete(cb: (succeededTags: string[]) => void): void;
+    static onNetworkError(cb: (item: IQueuedOperation) => void): void;
+    /**
+     * Add an operation to the pending queue and persist it.
+     * Called internally by RequestProvider when queue: true.
+     * Returns the stable ID of the queued item.
+     */
+    static enqueue(operation: Omit<IQueuedOperation, 'id' | 'createdAt' | 'flushAttempts' | 'status'>): Promise<string>;
+    static getQueue(tag?: string): IQueuedOperation[];
+    static getDeadLetterQueue(tag?: string): IDeadLetterItem[];
+    /**
+     * Flush queued items in FIFO order.
+     * Stops on first failure. Refreshes registry for succeeded tags only.
+     */
+    static flushAll(options?: IFlushOptions): Promise<void>;
+    /**
+     * Flush a specific pending item by ID, independent of queue position.
+     * On success: triggers registry refresh for its own tags.
+     * On failure: moves to dead-letter independently.
+     */
+    static flushOne(id: string): Promise<void>;
+    /**
+     * Move a dead-letter item back to the FRONT of the pending queue for retry.
+     * App should call flushAll() afterwards.
+     */
+    static retryOne(id: string): Promise<void>;
+    /**
+     * Permanently remove an item from either the pending queue or dead-letter store.
+     */
+    static discard(id: string): Promise<void>;
+    /**
+     * Reorder the pending queue by providing an ordered array of IDs.
+     * Fully permissive — causal ordering is the app's responsibility.
+     */
+    static reorder(ids: string[]): void;
+    private static regenerateHeaders;
+    private static executeRequest;
+    private static moveToDeadLetter;
+    private static persistQueue;
+    private static persistDeadLetter;
+    /** For testing only */
+    static _reset(): void;
+}
+
+interface IQueueStorageAdapter {
+    loadQueue(): Promise<IQueuedOperation[]>;
+    saveQueue(items: IQueuedOperation[]): Promise<void>;
+    loadDeadLetter(): Promise<IDeadLetterItem[]>;
+    saveDeadLetter(items: IDeadLetterItem[]): Promise<void>;
+}
+declare class QueueStorageFactory {
+    private static indexedDBAdapter;
+    private static localStorageAdapter;
+    private static memoryAdapter;
+    /**
+     * Returns an adapter for the requested backend.
+     * Falls back automatically if the requested backend is unavailable:
+     *   IndexedDB → LocalStorage → Memory
+     */
+    static getAdapter(backend: EQueueStorage): IQueueStorageAdapter;
+    static _reset(): void;
+}
+
+declare const compareIn: (rowValue: any, filterValue: any) => boolean;
+declare const compareEqual: (rowValue: any, filterValue: any) => boolean;
+declare const compareValues: (rowValue: any, filterValue: any) => number;
+declare const compareAnd: (row: TDataRow, nested: any) => boolean;
+declare const compareOr: (row: TDataRow, nested: any) => boolean;
+declare const applyOperator: (operator: string, rowValue: any, filterValue: any) => boolean;
+declare const evaluateFilter: (filter: IDataFilter, row: TDataRow) => boolean;
+declare const filterTreeData: (nodes: any[], filter: IDataFilter, options: {
+    idKey: string;
+    parentKey: string;
+}) => {
+    visibleNodes: any[];
+    expandedNodes: Set<string | number>;
+};
+declare const filterData: (data: any[], filter: IDataFilter, options?: {
+    treeOptions?: {
+        idKey: string;
+        parentKey: string;
+    };
+}) => {
+    results: any[];
+    expandedNodes?: Set<string | number>;
+};
+declare const useFilterLogic: () => {
+    evaluateFilter: (filter: IDataFilter, row: TDataRow) => boolean;
+    filterTreeData: (nodes: any[], filter: IDataFilter, options: {
+        idKey: string;
+        parentKey: string;
+    }) => {
+        visibleNodes: any[];
+        expandedNodes: Set<string | number>;
+    };
+    filterData: (data: any[], filter: IDataFilter, options?: {
+        treeOptions?: {
+            idKey: string;
+            parentKey: string;
+        };
+    }) => {
+        results: any[];
+        expandedNodes?: Set<string | number>;
+    };
+};
+
+declare const sortData: (sortList: IDataSort[], rows: TDataRow[]) => TDataRow[];
+declare const useSortLogic: () => {
+    sortData: (sortList: IDataSort[], rows: TDataRow[]) => TDataRow[];
+};
+
+interface IDebouncedFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+}
+declare const useDebounce: <T extends (...args: any[]) => any>(callback: T, delay: number) => IDebouncedFunction<T>;
+declare const debounce: <T extends (...args: any[]) => any>(callback: T, delay: number) => IDebouncedFunction<T>;
+
+/**
+ * defaultAdapter.ts — Framework-agnostic default implementation of ISSRHydrationAdapter.
+ * Pure Vanilla JS / React / Node.js with zero framework dependencies.
+ */
+
+declare class DefaultHydrationAdapter implements ISSRHydrationAdapter {
+    getSSRData<T>(key: string, context?: any): T | null;
+    fetchWithSSR<T>(key: string, fetcher: () => Promise<T>, context?: any): Promise<T | null>;
+    clearSSRData(key: string, context?: any): void;
+    getSSRPayload(context?: any): Record<string, any> | null;
+}
+
+/**
+ * index.ts — Framework-agnostic hydration and platform bridge.
+ * Provides unified, safe methods for SSR hydration, routing, and lifecycle hooks.
+ */
+
+declare function getHydrationAdapter(): ISSRHydrationAdapter;
+declare function setHydrationAdapter(adapter: ISSRHydrationAdapter): void;
+/**
+ * Retrieve SSR state for a key. Returns null if not found.
+ */
+declare function getSSRData<T>(key: string, context?: any): T | null;
+/**
+ * Execute fetcher with SSR caching/serialization or fallback directly.
+ */
+declare function fetchWithSSR<T>(key: string, fetcher: () => Promise<T>, context?: any): Promise<T | null>;
+/**
+ * Clear SSR data for a key.
+ */
+declare function clearSSRData(key: string, context?: any): void;
+/**
+ * Extract SSR payload dictionary for hydration of memory/storage caches.
+ */
+declare function getSSRPayload(context?: any): Record<string, any> | null;
+/**
+ * Safe platform app accessor.
+ */
+declare function getPlatformApp(): any;
+/**
+ * Safe route accessor with browser URLSearchParams fallback for React/Vanilla.
+ */
+declare function getAppRoute(): {
+    query: Record<string, any>;
+    path?: string;
+} | null;
+/**
+ * Safe router accessor with window.history fallback for React/Vanilla.
+ */
+declare function getAppRouter(): any;
+/**
+ * Register a callback when platform hydration is ready or DOMContentLoaded.
+ */
+declare function onPlatformReady(cb: () => void): void;
+
+export { AAPIDataProvider, ADataProvider, CAPIFlatClientDataProvider, CAPIFlatServerDataProvider, CAPITreeClientDataProvider, CAPITreeServerDataProvider, CApplicationCache, CCookieCache, CFlatClientDataProvider, CFlatServerDataProvider, CIndexedDBCache, CLocalStorageCache, CMemoryCache, CSessionCache, CTreeClientDataProvider, CTreeServerDataProvider, CacheProviderFactory, DefaultHydrationAdapter, ECacheStrategy, EDataFilterOperator, EQueueStorage, KatluxIndexedDB, QueueStorageFactory, RequestProvider, RequestProviderRegistry, RequestQueue, SENSITIVE_HEADER_KEYS, applyOperator, clearSSRData, compareAnd, compareEqual, compareIn, compareOr, compareValues, debounce, evaluateFilter, fetchWithSSR, filterData, filterTreeData, getAppRoute, getAppRouter, getHydrationAdapter, getPlatformApp, getSSRData, getSSRPayload, onPlatformReady, setHydrationAdapter, sortData, useDebounce, useFilterLogic, useSortLogic };
+export type { CacheDriverLoader, ICacheEntry, IDataFilter, IDataProviderOptions, IDataResult, IDataSort, IDeadLetterItem, IDebouncedFunction, IFlushOptions, IKDatatableAction, IPlatformRouter, IQueueStorageAdapter, IQueuedOperation, IRequestOptions, ISSRHydrationAdapter, ITreeDataProvider, ITreeDataProviderOptions, ITreeNode, ITreeNodeStatic, KProductItemData, KProductRowAction, TDataProviderListener, TDataRow, TKatluxStore, TPageDataHandler, TQueueItemStatus, TTreePageDataHandler, TTreeRow, TUnsubscribe, TreePaginationMode };