@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

package/dist/vue/router/routeResourceBinding/RouteResourceBoundView.d.ts

@@ -0,0 +1,57 @@
+import { type VNode } from 'vue';
+/**
+ * Drop-in replacement for `<router-view>` that handles route resource
+ * injection loading and error states.
+ *
+ * When any injected resource is loading → renders the route's `loadingComponent`.
+ * When any injected resource has an error → renders the route's `errorComponent`
+ *   (receives `error` and `refresh` as props).
+ * Otherwise → passes `{ Component, route }` to the default scoped slot,
+ *   just like `<RouterView>`.
+ *
+ * Error and loading components are defined in the route via `defineRoute`:
+ *
+ * ```ts
+ * defineRoute<{ credential: CredentialResource }>()({
+ *   path: '/credentials/:credentialId',
+ *   component: CredentialShowPage,
+ *   errorComponent: GenericErrorPage,
+ *   loadingComponent: LoadingSpinner,
+ *   inject: {
+ *     credential: {
+ *       from: 'credentialId',
+ *       resolve: (id) => new RouteResourceRequestResolver(new CredentialShowRequest(id)),
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * Set `lazy: false` to render the target component immediately (without
+ * waiting for resources). The component can then handle loading/error
+ * states itself via `useRouteResource()`:
+ *
+ * ```ts
+ * defineRoute<{ credential: CredentialResource }>()({
+ *   path: '/credentials/:credentialId',
+ *   component: CredentialShowPage,
+ *   lazy: false,
+ *   inject: { ... },
+ * })
+ * ```
+ *
+ * Usage in layout (supports the same v-slot pattern as RouterView):
+ * ```vue
+ * <RouteResourceBoundView v-slot="{ Component, route }">
+ *   <component :is="Component" v-if="Component" :key="route.meta.usePathKey ? route.path : undefined" />
+ *   <EmptyState v-else />
+ * </RouteResourceBoundView>
+ * ```
+ *
+ * Or without a slot (renders the matched component automatically):
+ * ```vue
+ * <RouteResourceBoundView />
+ * ```
+ */
+export declare const RouteResourceBoundView: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/vue/router/routeResourceBinding/RouteResourceBoundView.js

@@ -0,0 +1,135 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { computed, defineComponent, h } from 'vue';
+import { RouterView, useRoute } from 'vue-router';
+/**
+ * Drop-in replacement for `<router-view>` that handles route resource
+ * injection loading and error states.
+ *
+ * When any injected resource is loading → renders the route's `loadingComponent`.
+ * When any injected resource has an error → renders the route's `errorComponent`
+ *   (receives `error` and `refresh` as props).
+ * Otherwise → passes `{ Component, route }` to the default scoped slot,
+ *   just like `<RouterView>`.
+ *
+ * Error and loading components are defined in the route via `defineRoute`:
+ *
+ * ```ts
+ * defineRoute<{ credential: CredentialResource }>()({
+ *   path: '/credentials/:credentialId',
+ *   component: CredentialShowPage,
+ *   errorComponent: GenericErrorPage,
+ *   loadingComponent: LoadingSpinner,
+ *   inject: {
+ *     credential: {
+ *       from: 'credentialId',
+ *       resolve: (id) => new RouteResourceRequestResolver(new CredentialShowRequest(id)),
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * Set `lazy: false` to render the target component immediately (without
+ * waiting for resources). The component can then handle loading/error
+ * states itself via `useRouteResource()`:
+ *
+ * ```ts
+ * defineRoute<{ credential: CredentialResource }>()({
+ *   path: '/credentials/:credentialId',
+ *   component: CredentialShowPage,
+ *   lazy: false,
+ *   inject: { ... },
+ * })
+ * ```
+ *
+ * Usage in layout (supports the same v-slot pattern as RouterView):
+ * ```vue
+ * <RouteResourceBoundView v-slot="{ Component, route }">
+ *   <component :is="Component" v-if="Component" :key="route.meta.usePathKey ? route.path : undefined" />
+ *   <EmptyState v-else />
+ * </RouteResourceBoundView>
+ * ```
+ *
+ * Or without a slot (renders the matched component automatically):
+ * ```vue
+ * <RouteResourceBoundView />
+ * ```
+ */
+export const RouteResourceBoundView = defineComponent({
+    name: 'RouteResourceBoundView',
+    setup(_, { slots }) {
+        const route = useRoute();
+        const injectionState = computed(() => {
+            return route.meta._injectionState;
+        });
+        const firstError = computed(() => {
+            const state = injectionState.value;
+            if (!state)
+                return null;
+            for (const key of Object.keys(state)) {
+                const entry = state[key];
+                if (entry === null || entry === void 0 ? void 0 : entry.error)
+                    return entry.error;
+            }
+            return null;
+        });
+        const anyLoading = computed(() => {
+            const state = injectionState.value;
+            if (!state)
+                return false;
+            return Object.keys(state).some((key) => { var _a; return (_a = state[key]) === null || _a === void 0 ? void 0 : _a.loading; });
+        });
+        const refresh = () => __awaiter(this, void 0, void 0, function* () {
+            const state = injectionState.value;
+            if (!state)
+                return;
+            const erroredProps = Object.keys(state).filter((key) => { var _a; return (_a = state[key]) === null || _a === void 0 ? void 0 : _a.error; });
+            yield Promise.all(erroredProps.map((propName) => { var _a, _b; return (_b = (_a = route.meta).refresh) === null || _b === void 0 ? void 0 : _b.call(_a, propName); }));
+        });
+        /**
+         * Core render logic that decides which slot/component to show
+         * given the resolved Component and route from RouterView.
+         */
+        function renderContent(Component, resolvedRoute) {
+            var _a, _b;
+            const isLazy = resolvedRoute.meta._lazy !== false;
+            if (isLazy) {
+                if (firstError.value) {
+                    const errorComponent = resolvedRoute.meta._errorComponent;
+                    if (errorComponent) {
+                        return h(errorComponent, { error: firstError.value, refresh });
+                    }
+                    return (_a = slots['error']) === null || _a === void 0 ? void 0 : _a.call(slots, { error: firstError.value, refresh });
+                }
+                if (anyLoading.value) {
+                    const loadingComponent = resolvedRoute.meta._loadingComponent;
+                    if (loadingComponent) {
+                        return h(loadingComponent);
+                    }
+                    return (_b = slots['loading']) === null || _b === void 0 ? void 0 : _b.call(slots);
+                }
+            }
+            if (slots['default']) {
+                return slots['default']({ Component, route: resolvedRoute });
+            }
+            if (Component) {
+                return h(Component);
+            }
+            return undefined;
+        }
+        return () => {
+            return h(RouterView, null, {
+                default: ({ Component, route: resolvedRoute }) => {
+                    return renderContent(Component, resolvedRoute);
+                }
+            });
+        };
+    }
+});

package/dist/vue/router/routeResourceBinding/RouteResourceRequestResolver.d.ts

@@ -0,0 +1,6 @@
+import { type DataRequest, type Resolver } from './types';
+export declare class RouteResourceRequestResolver<T> implements Resolver<T> {
+    private request;
+    constructor(request: DataRequest<T>);
+    resolve(): Promise<T>;
+}

package/dist/vue/router/routeResourceBinding/RouteResourceRequestResolver.js

@@ -0,0 +1,20 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class RouteResourceRequestResolver {
+    constructor(request) {
+        this.request = request;
+    }
+    resolve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request.send();
+            return response.getData();
+        });
+    }
+}

package/dist/vue/router/routeResourceBinding/defineRoute.d.ts

@@ -0,0 +1,23 @@
+import { type Component } from 'vue';
+import { type RouteRecordRaw } from 'vue-router';
+import { type InjectConfig } from './types';
+/**
+ * Type-safe route definition helper that ties:
+ * - component props type (Props)
+ * - inject config types (must resolve Props[K])
+ *
+ * Usage:
+ * export default defineRoute<{ product: ProductResource }>()({
+ *   path: '/products/:productId',
+ *   component: ProductShowPage,
+ *   errorComponent: GenericErrorPage,
+ *   loadingComponent: LoadingSpinner,
+ *   inject: { product: { from: 'productId', resolve: ... } },
+ * })
+ */
+export declare function defineRoute<Props extends Record<string, unknown>>(): <T extends RouteRecordRaw & {
+    inject?: InjectConfig<Props>;
+    errorComponent?: Component;
+    loadingComponent?: Component;
+    lazy?: boolean;
+}>(route: T) => RouteRecordRaw;

package/dist/vue/router/routeResourceBinding/defineRoute.js

@@ -0,0 +1,42 @@
+import { markRaw } from 'vue';
+/**
+ * Type-safe route definition helper that ties:
+ * - component props type (Props)
+ * - inject config types (must resolve Props[K])
+ *
+ * Usage:
+ * export default defineRoute<{ product: ProductResource }>()({
+ *   path: '/products/:productId',
+ *   component: ProductShowPage,
+ *   errorComponent: GenericErrorPage,
+ *   loadingComponent: LoadingSpinner,
+ *   inject: { product: { from: 'productId', resolve: ... } },
+ * })
+ */
+export function defineRoute() {
+    return function (route) {
+        var _a, _b, _c;
+        const originalProps = route.props;
+        if (route.errorComponent) {
+            route.meta = (_a = route.meta) !== null && _a !== void 0 ? _a : {};
+            route.meta._errorComponent = markRaw(route.errorComponent);
+            delete route.errorComponent;
+        }
+        if (route.loadingComponent) {
+            route.meta = (_b = route.meta) !== null && _b !== void 0 ? _b : {};
+            route.meta._loadingComponent = markRaw(route.loadingComponent);
+            delete route.loadingComponent;
+        }
+        if (route.lazy !== undefined) {
+            route.meta = (_c = route.meta) !== null && _c !== void 0 ? _c : {};
+            route.meta._lazy = route.lazy;
+            delete route.lazy;
+        }
+        route.props = (to) => {
+            var _a;
+            const baseProps = typeof originalProps === 'function' ? originalProps(to) : originalProps === true ? to.params : (originalProps !== null && originalProps !== void 0 ? originalProps : {});
+            return Object.assign(Object.assign({}, baseProps), ((_a = to.meta._injectedProps) !== null && _a !== void 0 ? _a : {}));
+        };
+        return route;
+    };
+}

package/dist/vue/router/routeResourceBinding/index.d.ts

@@ -0,0 +1,8 @@
+import { defineRoute } from './defineRoute';
+import { installRouteInjection } from './installRouteInjection';
+import { RouteResourceBoundView } from './RouteResourceBoundView';
+import { RouteResourceRequestResolver } from './RouteResourceRequestResolver';
+import { useRouteResource } from './useRouteResource';
+import type { DataRequest, InjectConfig, Resolver } from './types';
+export { defineRoute, installRouteInjection, RouteResourceBoundView, RouteResourceRequestResolver, useRouteResource };
+export type { DataRequest, InjectConfig, Resolver };

package/dist/vue/router/routeResourceBinding/index.js

@@ -0,0 +1,6 @@
+import { defineRoute } from './defineRoute';
+import { installRouteInjection } from './installRouteInjection';
+import { RouteResourceBoundView } from './RouteResourceBoundView';
+import { RouteResourceRequestResolver } from './RouteResourceRequestResolver';
+import { useRouteResource } from './useRouteResource';
+export { defineRoute, installRouteInjection, RouteResourceBoundView, RouteResourceRequestResolver, useRouteResource };

package/dist/vue/router/routeResourceBinding/installRouteInjection.d.ts

@@ -0,0 +1,14 @@
+import { type Router } from 'vue-router';
+/**
+ * Installs the runtime part:
+ * - resolves all route.inject entries before navigation completes
+ * - stores results on to.meta._injectedProps
+ * - ensures route props include injected results (so components receive them as props)
+ * - caches resolved resources so child routes inherit parent-resolved data
+ *   without triggering redundant requests (as long as the param value is unchanged)
+ *
+ * Notes:
+ * - This keeps router files clean: only an `inject` block per route.
+ * - This is intentionally runtime-generic; type safety happens at route definition time.
+ */
+export declare function installRouteInjection(router: Router): void;

package/dist/vue/router/routeResourceBinding/installRouteInjection.js

@@ -0,0 +1,133 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { reactive } from 'vue';
+/**
+ * Installs the runtime part:
+ * - resolves all route.inject entries before navigation completes
+ * - stores results on to.meta._injectedProps
+ * - ensures route props include injected results (so components receive them as props)
+ * - caches resolved resources so child routes inherit parent-resolved data
+ *   without triggering redundant requests (as long as the param value is unchanged)
+ *
+ * Notes:
+ * - This keeps router files clean: only an `inject` block per route.
+ * - This is intentionally runtime-generic; type safety happens at route definition time.
+ */
+export function installRouteInjection(router) {
+    const cache = {};
+    router.beforeResolve((to) => __awaiter(this, void 0, void 0, function* () {
+        console.log('[Route Injection] Resolving route injections...');
+        if (!to.meta._injectedProps) {
+            to.meta._injectedProps = reactive({});
+        }
+        if (!to.meta._injectionState) {
+            to.meta._injectionState = reactive({});
+        }
+        const resolvers = {};
+        const activePropNames = new Set();
+        const pendingResolvers = [];
+        // Iterate through all matched route records (from parent to child)
+        for (const record of to.matched) {
+            console.debug(`[Route Injection] Processing route "${record.path}"`);
+            // Access the custom 'inject' property directly from the record
+            const inject = record.meta.inject;
+            if (!inject) {
+                console.debug(`[Route Injection] No injections found for route "${record.path}"`);
+                continue;
+            }
+            for (const [propName, cfg] of Object.entries(inject)) {
+                const rawParam = to.params[cfg.from];
+                if (rawParam === undefined || rawParam === null) {
+                    console.warn(`[Route Injection] Param "${cfg.from}" not found for prop "${propName}"`);
+                    continue;
+                }
+                const paramValue = Array.isArray(rawParam) ? rawParam[0] : String(rawParam);
+                if (paramValue === undefined || paramValue === null) {
+                    console.warn(`[Route Injection] Param value "${cfg.from}" not found for prop "${propName}"`);
+                    continue;
+                }
+                activePropNames.add(propName);
+                // Initialize state for this prop
+                const state = to.meta._injectionState;
+                if (!state[propName]) {
+                    state[propName] = reactive({ loading: false, error: null });
+                }
+                // Define the refresh logic for this specific prop (always fetches fresh data)
+                const resolveProp = (options) => __awaiter(this, void 0, void 0, function* () {
+                    const propState = to.meta._injectionState[propName];
+                    if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                        propState.loading = true;
+                    }
+                    propState.error = null;
+                    try {
+                        const resolver = cfg.resolve(paramValue);
+                        let payload = yield resolver.resolve();
+                        if (typeof cfg.getter === 'function') {
+                            payload = cfg.getter(payload);
+                        }
+                        // Update cache
+                        cache[propName] = { paramValue, payload };
+                        // Updating the reactive object triggers the component re-render
+                        const injectedProps = to.meta._injectedProps;
+                        injectedProps[propName] = payload;
+                        return payload;
+                    }
+                    catch (e) {
+                        propState.error = e instanceof Error ? e : new Error(String(e));
+                        throw e;
+                    }
+                    finally {
+                        propState.loading = false;
+                    }
+                });
+                resolvers[propName] = resolveProp;
+                // Reuse cached value if the param hasn't changed (e.g. navigating between child routes)
+                const cached = cache[propName];
+                if (cached && cached.paramValue === paramValue) {
+                    console.debug(`[Route Injection] Using cached value for prop "${propName}" (param "${cfg.from}" unchanged)`);
+                    const injectedPropsCache = to.meta._injectedProps;
+                    injectedPropsCache[propName] = cached.payload;
+                    continue;
+                }
+                // Set loading immediately and queue resolver (non-blocking)
+                const injectionState = to.meta._injectionState;
+                injectionState[propName].loading = true;
+                pendingResolvers.push(() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield resolveProp();
+                    }
+                    catch (e) {
+                        console.error(`[Route Injection] Failed to resolve prop "${propName}"`, e);
+                    }
+                }));
+                console.debug(`[Route Injection] Queued resolution for prop "${propName}" for route "${record.path}"`);
+            }
+        }
+        // Evict cache entries that are no longer part of the active route hierarchy
+        for (const key of Object.keys(cache)) {
+            if (!activePropNames.has(key)) {
+                delete cache[key];
+            }
+        }
+        // Attach the resolvers and a global refresh helper to the route meta
+        to.meta['_injectedResolvers'] = resolvers;
+        to.meta['refresh'] = (propName, options) => __awaiter(this, void 0, void 0, function* () {
+            if (resolvers[propName]) {
+                return yield resolvers[propName](options);
+            }
+            console.warn(`[Route Injection] No resolver found for "${propName}"`);
+            return undefined;
+        });
+        // Fire pending resolvers without blocking navigation
+        if (pendingResolvers.length > 0) {
+            Promise.all(pendingResolvers.map((fn) => fn()));
+        }
+    }));
+}

package/dist/vue/router/routeResourceBinding/types.d.ts

@@ -0,0 +1,55 @@
+import { type Component } from 'vue';
+import { type RouteLocationNormalized } from 'vue-router';
+/**
+ * Generic resolver interface.
+ */
+export interface Resolver<T> {
+    resolve(): Promise<T>;
+}
+/**
+ * A minimal "request" contract that matches your request classes:
+ * new ProductShowRequest(id).send() -> { getData(): T }
+ */
+export interface DataRequest<T> {
+    send(): Promise<{
+        getData(): T;
+    }>;
+}
+/**
+ * Inject config that is type-safe against component props.
+ *
+ * Props[K] is the required resolved type for prop K.
+ */
+export type InjectConfig<Props extends Record<string, unknown>> = {
+    [K in keyof Props]?: {
+        /**
+         * Route param name, e.g. "productId"
+         */
+        from: keyof RouteLocationNormalized['params'] | string;
+        /**
+         * Create a resolver from the param value.
+         * Param value is treated as string (most common in routes).
+         */
+        resolve: (param: string) => Resolver<Props[K]>;
+    };
+};
+/**
+ * Extended route meta to store injected props at runtime.
+ */
+declare module 'vue-router' {
+    interface RouteMeta {
+        _injectedProps?: Record<string, unknown>;
+        _injectedResolvers?: Record<string, () => Promise<unknown>>;
+        _injectionState?: Record<string, {
+            loading: boolean;
+            error: Error | null;
+        }>;
+        _errorComponent?: Component;
+        _loadingComponent?: Component;
+        _lazy?: boolean;
+        refresh?: (propName: string, options?: {
+            silent?: boolean;
+        }) => Promise<unknown>;
+        inject?: Record<string, unknown>;
+    }
+}

package/dist/vue/router/routeResourceBinding/types.js

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

package/dist/vue/router/routeResourceBinding/useRouteResource.d.ts

@@ -0,0 +1,8 @@
+import { type ComputedRef } from 'vue';
+export declare function useRouteResource(propName: string): {
+    refresh: (options?: {
+        silent?: boolean;
+    }) => Promise<unknown>;
+    isLoading: ComputedRef<boolean>;
+    error: ComputedRef<Error | null>;
+};

package/dist/vue/router/routeResourceBinding/useRouteResource.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { computed } from 'vue';
+import { useRoute } from 'vue-router';
+export function useRouteResource(propName) {
+    const route = useRoute();
+    const refresh = (options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        return yield ((_b = (_a = route.meta).refresh) === null || _b === void 0 ? void 0 : _b.call(_a, propName, options));
+    });
+    const isLoading = computed(() => {
+        var _a, _b;
+        const state = route.meta._injectionState;
+        return (_b = (_a = state === null || state === void 0 ? void 0 : state[propName]) === null || _a === void 0 ? void 0 : _a.loading) !== null && _b !== void 0 ? _b : false;
+    });
+    const error = computed(() => {
+        var _a, _b;
+        const state = route.meta._injectionState;
+        return (_b = (_a = state === null || state === void 0 ? void 0 : state[propName]) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : null;
+    });
+    return { refresh, isLoading, error };
+}

package/dist/vue/state/State.d.ts

@@ -0,0 +1,75 @@
+import { type PersistenceDriver } from '../../persistenceDrivers';
+export interface StateOptions {
+    persist?: boolean;
+    persistSuffix?: string;
+}
+/** Generic type for change handlers. */
+type ChangeHandler<T> = (val: T, oldVal: T) => void;
+/** Type for accessing nested properties with dot notation. */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? T[K] extends Record<string, unknown> ? PathValue<T[K], Rest> : never : never : never;
+/** Helper type to get all possible paths in an object. */
+type PathsToStringProps<T> = T extends object ? {
+    [K in keyof T]: K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never;
+}[keyof T] : never;
+/** Union type of all possible dot-notation paths in T. */
+type Path<T> = keyof T | PathsToStringProps<T>;
+export declare abstract class State<T extends object> {
+    private readonly properties;
+    private readonly _initial;
+    private readonly _persist;
+    private readonly _persistKey;
+    private _driver;
+    private _stateProxy;
+    private _watchStopFunctions;
+    private _resetHandlers;
+    private _watchIdCounter;
+    protected constructor(initial: T, options?: StateOptions);
+    /**
+     * Safe deep clone that preserves types
+     */
+    private deepClone;
+    /**
+     * Ensure objects/arrays are cloned and wrapped in Vue reactivity.
+     */
+    private wrapReactive;
+    /**
+     * Get a proxy to the state that allows direct property access and setting
+     * without using .value
+     */
+    get state(): T;
+    /**
+     * Add a subscription to specific properties or nested properties
+     * @param paths Path(s) to the property. Can be:
+     *              - A single path (top-level key or nested with dot notation)
+     *              - An array of paths to watch (triggers when any changes)
+     * @param handler Function to call when the property changes
+     * @param options Optional configuration for debounce and executeOnReset
+     * @returns A function to remove the subscription
+     */
+    subscribe<P extends Path<T>>(paths: P, handler: ChangeHandler<PathValue<T, P & string>>, options?: {
+        debounce?: number;
+        executeOnReset?: boolean;
+    }): () => void;
+    subscribe<P extends Path<T>>(paths: P[], handler: (changedPath: P, state: T) => void, options?: {
+        debounce?: number;
+        executeOnReset?: boolean;
+    }): () => void;
+    /**
+     * Internal method to set up a watcher for a specific path
+     */
+    private setupWatcher;
+    /**
+     * Simple deep equality check
+     */
+    private isEqual;
+    protected getPersistenceDriver(): PersistenceDriver;
+    export(): T;
+    import(data: Partial<T>): void;
+    reset(): void;
+    get persistKey(): string;
+    /**
+     * Clean up all watchers when the state is no longer needed
+     */
+    destroy(): void;
+}
+export {};