akanjs 2.2.4 → 2.2.6

package/types/store/baseSt.d.ts

@@ -0,0 +1,412 @@
+import type { PageState } from "akanjs/client";
+import { Responsive } from "akanjs/constant";
+import { type Account } from "akanjs/fetch";
+import type { SignalType } from "akanjs/signal";
+declare const defaultMessage: {
+    type: "info" | "success" | "error" | "warning" | "loading";
+    content: string;
+    duration: number;
+    key: string;
+};
+export type BaseSearchParamsState = {
+    [key: string]: string | string[];
+};
+export declare const getBaseSearchParam: (searchParams: BaseSearchParamsState, key: string) => string;
+declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./stateBuilder.d.ts").WritableStateOf<{
+    csrLoaded: boolean;
+    path: string;
+    pathname: string;
+    params: {
+        [key: string]: string;
+    };
+    searchParams: BaseSearchParamsState;
+    theme: string;
+    innerWidth: number;
+    innerHeight: number;
+    responsive: Responsive["value"];
+    uiOperation: "sleep" | "loading" | "idle";
+    messages: (typeof defaultMessage)[];
+    tryJwt: string | null;
+    trySignalType: SignalType;
+    tryRoles: string[];
+    tryAccount: Account<{
+        [key: string]: string | undefined;
+    }>;
+    keyboardHeight: number;
+    pageState: PageState;
+    devMode: boolean;
+    deviceToken: string;
+    currentPath: string;
+}>, unknown, any, unknown, import("./stateBuilder.d.ts").WritableStateOf<{
+    csrLoaded: boolean;
+    path: string;
+    pathname: string;
+    params: {
+        [key: string]: string;
+    };
+    searchParams: BaseSearchParamsState;
+    theme: string;
+    innerWidth: number;
+    innerHeight: number;
+    responsive: Responsive["value"];
+    uiOperation: "sleep" | "loading" | "idle";
+    messages: (typeof defaultMessage)[];
+    tryJwt: string | null;
+    trySignalType: SignalType;
+    tryRoles: string[];
+    tryAccount: Account<{
+        [key: string]: string | undefined;
+    }>;
+    keyboardHeight: number;
+    pageState: PageState;
+    devMode: boolean;
+    deviceToken: string;
+    currentPath: string;
+}>, any, any, any, any, any, "Base", any, any>;
+export declare class BaseStore extends BaseStore_base {
+    setDevMode(value: boolean): void;
+    setWindowSize(): void;
+    showMessage(message: {
+        content: string | string[];
+    } & Partial<typeof defaultMessage>): void;
+    hideMessage(key: string): void;
+}
+export declare const base: typeof BaseStore;
+declare const RootStore_base: import("./rootStore.d.ts").RootStoreCls<"root", import("./stateBuilder.d.ts").WritableStateOf<{
+    csrLoaded: boolean;
+    path: string;
+    pathname: string;
+    params: {
+        [key: string]: string;
+    };
+    searchParams: BaseSearchParamsState;
+    theme: string;
+    innerWidth: number;
+    innerHeight: number;
+    responsive: Responsive["value"];
+    uiOperation: "sleep" | "loading" | "idle";
+    messages: (typeof defaultMessage)[];
+    tryJwt: string | null;
+    trySignalType: SignalType;
+    tryRoles: string[];
+    tryAccount: Account<{
+        [key: string]: string | undefined;
+    }>;
+    keyboardHeight: number;
+    pageState: PageState;
+    devMode: boolean;
+    deviceToken: string;
+    currentPath: string;
+}>, Omit<BaseStore, "slice" | keyof import("./types.d.ts").SetGet<any>>, {
+    [x: `base${Capitalize<string>}`]: import("./types.d.ts").InternalSlice<any, "base", string, any, any, any, any, any, "Base", any, any>;
+}, any>;
+export declare class RootStore extends RootStore_base {
+}
+export declare const st: {
+    sub: {
+        (listener: (state: import("./stateBuilder.d.ts").WritableStateOf<{
+            csrLoaded: boolean;
+            path: string;
+            pathname: string;
+            params: {
+                [key: string]: string;
+            };
+            searchParams: BaseSearchParamsState;
+            theme: string;
+            innerWidth: number;
+            innerHeight: number;
+            responsive: Responsive["value"];
+            uiOperation: "sleep" | "loading" | "idle";
+            messages: (typeof defaultMessage)[];
+            tryJwt: string | null;
+            trySignalType: SignalType;
+            tryRoles: string[];
+            tryAccount: Account<{
+                [key: string]: string | undefined;
+            }>;
+            keyboardHeight: number;
+            pageState: PageState;
+            devMode: boolean;
+            deviceToken: string;
+            currentPath: string;
+        }>, prev: import("./stateBuilder.d.ts").WritableStateOf<{
+            csrLoaded: boolean;
+            path: string;
+            pathname: string;
+            params: {
+                [key: string]: string;
+            };
+            searchParams: BaseSearchParamsState;
+            theme: string;
+            innerWidth: number;
+            innerHeight: number;
+            responsive: Responsive["value"];
+            uiOperation: "sleep" | "loading" | "idle";
+            messages: (typeof defaultMessage)[];
+            tryJwt: string | null;
+            trySignalType: SignalType;
+            tryRoles: string[];
+            tryAccount: Account<{
+                [key: string]: string | undefined;
+            }>;
+            keyboardHeight: number;
+            pageState: PageState;
+            devMode: boolean;
+            deviceToken: string;
+            currentPath: string;
+        }>) => void): () => void;
+        <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
+            csrLoaded: boolean;
+            path: string;
+            pathname: string;
+            params: {
+                [key: string]: string;
+            };
+            searchParams: BaseSearchParamsState;
+            theme: string;
+            innerWidth: number;
+            innerHeight: number;
+            responsive: Responsive["value"];
+            uiOperation: "sleep" | "loading" | "idle";
+            messages: (typeof defaultMessage)[];
+            tryJwt: string | null;
+            trySignalType: SignalType;
+            tryRoles: string[];
+            tryAccount: Account<{
+                [key: string]: string | undefined;
+            }>;
+            keyboardHeight: number;
+            pageState: PageState;
+            devMode: boolean;
+            deviceToken: string;
+            currentPath: string;
+        }>) => U, listener: (state: U, prev: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+    ref: <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
+        csrLoaded: boolean;
+        path: string;
+        pathname: string;
+        params: {
+            [key: string]: string;
+        };
+        searchParams: BaseSearchParamsState;
+        theme: string;
+        innerWidth: number;
+        innerHeight: number;
+        responsive: Responsive["value"];
+        uiOperation: "sleep" | "loading" | "idle";
+        messages: (typeof defaultMessage)[];
+        tryJwt: string | null;
+        trySignalType: SignalType;
+        tryRoles: string[];
+        tryAccount: Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: number;
+        pageState: PageState;
+        devMode: boolean;
+        deviceToken: string;
+        currentPath: string;
+    }>) => U) => import("react").RefObject<U>;
+    sel: <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
+        csrLoaded: boolean;
+        path: string;
+        pathname: string;
+        params: {
+            [key: string]: string;
+        };
+        searchParams: BaseSearchParamsState;
+        theme: string;
+        innerWidth: number;
+        innerHeight: number;
+        responsive: Responsive["value"];
+        uiOperation: "sleep" | "loading" | "idle";
+        messages: (typeof defaultMessage)[];
+        tryJwt: string | null;
+        trySignalType: SignalType;
+        tryRoles: string[];
+        tryAccount: Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: number;
+        pageState: PageState;
+        devMode: boolean;
+        deviceToken: string;
+        currentPath: string;
+    }>) => U, equals?: ((a: U, b: U) => boolean) | undefined) => U;
+    use: {
+        csrLoaded: () => boolean;
+        path: () => string;
+        pathname: () => string;
+        params: () => {
+            [key: string]: string;
+        };
+        searchParams: () => BaseSearchParamsState;
+        theme: () => string;
+        innerWidth: () => number;
+        innerHeight: () => number;
+        responsive: () => "xl" | "lg" | "md" | "sm" | "xs";
+        uiOperation: () => "loading" | "sleep" | "idle";
+        messages: () => {
+            type: "info" | "success" | "error" | "warning" | "loading";
+            content: string;
+            duration: number;
+            key: string;
+        }[];
+        tryJwt: () => string | null;
+        trySignalType: () => SignalType;
+        tryRoles: () => string[];
+        tryAccount: () => Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: () => number;
+        pageState: () => PageState;
+        devMode: () => boolean;
+        deviceToken: () => string;
+        currentPath: () => string;
+    };
+    do: RootStore & {
+        setCsrLoaded: (value: boolean) => void;
+        setPath: (value: string) => void;
+        setPathname: (value: string) => void;
+        setParams: (value: {
+            [key: string]: string;
+        }) => void;
+        setSearchParams: (value: BaseSearchParamsState) => void;
+        setTheme: (value: string) => void;
+        setInnerWidth: (value: number) => void;
+        setInnerHeight: (value: number) => void;
+        setResponsive: (value: "xl" | "lg" | "md" | "sm" | "xs") => void;
+        setUiOperation: (value: "loading" | "sleep" | "idle") => void;
+        setMessages: (value: {
+            type: "info" | "success" | "error" | "warning" | "loading";
+            content: string;
+            duration: number;
+            key: string;
+        }[]) => void;
+        setTryJwt: (value: string | null) => void;
+        setTrySignalType: (value: SignalType) => void;
+        setTryRoles: (value: string[]) => void;
+        setTryAccount: (value: Account<{
+            [key: string]: string | undefined;
+        }>) => void;
+        setKeyboardHeight: (value: number) => void;
+        setPageState: (value: PageState) => void;
+        setDevMode: (value: boolean) => void;
+        setDeviceToken: (value: string) => void;
+        setCurrentPath: (value: string) => void;
+    };
+    get: () => import("./stateBuilder.d.ts").WritableStateOf<{
+        csrLoaded: boolean;
+        path: string;
+        pathname: string;
+        params: {
+            [key: string]: string;
+        };
+        searchParams: BaseSearchParamsState;
+        theme: string;
+        innerWidth: number;
+        innerHeight: number;
+        responsive: Responsive["value"];
+        uiOperation: "sleep" | "loading" | "idle";
+        messages: (typeof defaultMessage)[];
+        tryJwt: string | null;
+        trySignalType: SignalType;
+        tryRoles: string[];
+        tryAccount: Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: number;
+        pageState: PageState;
+        devMode: boolean;
+        deviceToken: string;
+        currentPath: string;
+    }>;
+    set: (state: Partial<import("./stateBuilder.d.ts").WritableStateOf<{
+        csrLoaded: boolean;
+        path: string;
+        pathname: string;
+        params: {
+            [key: string]: string;
+        };
+        searchParams: BaseSearchParamsState;
+        theme: string;
+        innerWidth: number;
+        innerHeight: number;
+        responsive: Responsive["value"];
+        uiOperation: "sleep" | "loading" | "idle";
+        messages: (typeof defaultMessage)[];
+        tryJwt: string | null;
+        trySignalType: SignalType;
+        tryRoles: string[];
+        tryAccount: Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: number;
+        pageState: PageState;
+        devMode: boolean;
+        deviceToken: string;
+        currentPath: string;
+    }>> | ((state: import("./stateBuilder.d.ts").WritableStateOf<{
+        csrLoaded: boolean;
+        path: string;
+        pathname: string;
+        params: {
+            [key: string]: string;
+        };
+        searchParams: BaseSearchParamsState;
+        theme: string;
+        innerWidth: number;
+        innerHeight: number;
+        responsive: Responsive["value"];
+        uiOperation: "sleep" | "loading" | "idle";
+        messages: (typeof defaultMessage)[];
+        tryJwt: string | null;
+        trySignalType: SignalType;
+        tryRoles: string[];
+        tryAccount: Account<{
+            [key: string]: string | undefined;
+        }>;
+        keyboardHeight: number;
+        pageState: PageState;
+        devMode: boolean;
+        deviceToken: string;
+        currentPath: string;
+    }>) => any)) => void;
+    slice: {
+        [x: `base${Capitalize<string>}`]: import("./withSelector.d.ts").SliceSelectors<"base", import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, "Base", "", any, any>, {
+            initBase: (...args: any[]) => Promise<void>;
+        } & {
+            refreshBase: (initForm?: (import("akanjs/fetch").FetchInitForm<any, any, import("../base.d.ts").GetStateObject<{
+                [x: string]: any;
+            }>, any> & import("../common.d.ts").FetchPolicy<unknown> & {
+                queryArgs?: any[] | undefined;
+            }) | undefined) => Promise<void>;
+        } & {
+            selectBase: (model: any, options?: {
+                refresh?: boolean;
+                remove?: boolean;
+            }) => void;
+        } & {
+            setPageOfBase: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+        } & {
+            addPageOfBase: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+        } & {
+            setLimitOfBase: (limit: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+        } & {
+            setQueryArgsOfBase: (...args: any[] | [setQueryArgs: (...prevQueryArgs: any[]) => any[], options?: import("../common.d.ts").FetchPolicy<unknown> | undefined]) => Promise<void>;
+        } & {
+            setSortOfBase: (sort: any, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+        } & {
+            refName: "base";
+            suffix: string;
+            sliceName: `base${Capitalize<string>}`;
+            get: () => import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, "Base", "", any, any>;
+            set: (setState: Partial<import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, "Base", "", any, any>> | ((state: import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, "Base", "", any, any>) => void)) => void;
+        }>;
+    };
+};
+export {};

package/types/store/hooks.d.ts

@@ -0,0 +1 @@
+export { useEffect, useRef, useSyncExternalStore } from "react";

package/types/store/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./action.d.ts";
+export * from "./baseSt.d.ts";
+export * from "./rootStore.d.ts";
+export * from "./state.d.ts";
+export * from "./stateBuilder.d.ts";
+export * from "./store.d.ts";
+export * from "./storeRegistry.d.ts";
+export * from "./types.d.ts";

package/types/store/rootStore.d.ts

@@ -0,0 +1,22 @@
+import type { ACTION_META, Cls, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
+import type { SerializedSlice } from "akanjs/signal";
+import type { StateDerivedMeta, StateInitializerMap } from "./stateBuilder.d.ts";
+import type { SetGetWritable } from "./types.d.ts";
+export type RootStoreCls<RefName extends string = any, WritableState = any, Action = any, InternalSliceObj = any, SliceInfoObj = any, DerivedState = unknown, State = WritableState & DerivedState> = Cls<SetGetWritable<WritableState, State> & Action & {
+    slice: InternalSliceObj;
+}, {
+    readonly type: "root";
+    refName: RefName;
+    [STATE_META]: State;
+    [STATE_INIT_META]: StateInitializerMap;
+    [STATE_DERIVED_META]: StateDerivedMeta;
+    [ACTION_META]: {
+        [key: string]: (...args: any[]) => any;
+    };
+    slice: {
+        [key: string]: {
+            [key: string]: SerializedSlice;
+        };
+    };
+    _slice: SliceInfoObj;
+}>;

package/types/store/state.d.ts

@@ -0,0 +1,91 @@
+import { DataList, type SLICE_META } from "akanjs/base";
+import { type DefaultOf } from "akanjs/constant";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+import type { SerializedSlice, SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type { Submit } from "./types.d.ts";
+export type SliceStateKey = "defaultModel" | "modelInsight" | "modelList" | "modelListLoading" | "modelInitList" | "modelInitAt" | "modelSelection" | "lastPageOfModel" | "pageOfModel" | "limitOfModel" | "queryArgsOfModel" | "sortOfModel";
+type BaseState<RefName extends string, Full, _Default = DefaultOf<Full>> = {
+    [K in RefName]: Full | null;
+} & {
+    [K in `${RefName}Loading`]: string | boolean;
+} & {
+    [K in `${RefName}Form`]: _Default;
+} & {
+    [K in `${RefName}FormLoading`]: string | boolean;
+} & {
+    [K in `${RefName}Submit`]: Submit;
+} & {
+    [K in `${RefName}ViewAt`]: Date;
+} & {
+    [K in `${RefName}Modal`]: string | null;
+} & {
+    [K in `${RefName}Operation`]: "sleep" | "reset" | "idle" | "error" | "loading";
+};
+export type SliceState<RefName extends string, Suffix extends string, Full, Light extends {
+    id: string;
+}, Args, Insight, Filter extends FilterInstance, _CapitalizedRefName extends string = Capitalize<RefName>, _CapitalizedSuffix extends string = Capitalize<Suffix>, _Default = DefaultOf<Full>, _Sort = ExtractSort<Filter>> = {
+    [K in `default${_CapitalizedRefName}${_CapitalizedSuffix}`]: _Default;
+} & {
+    [K in `${RefName}List${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+    [K in `${RefName}ListLoading${_CapitalizedSuffix}`]: boolean;
+} & {
+    [K in `${RefName}InitList${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+    [K in `${RefName}InitAt${_CapitalizedSuffix}`]: Date;
+} & {
+    [K in `${RefName}Selection${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+    [K in `${RefName}Insight${_CapitalizedSuffix}`]: Insight;
+} & {
+    [K in `lastPageOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+    [K in `pageOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+    [K in `limitOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+    [K in `queryArgsOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: Args;
+} & {
+    [K in `sortOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: _Sort;
+};
+type _SliceMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
+type _SuffixStr<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Suffix & string;
+type _SuffixCap<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Capitalize<_SuffixStr<SlceCls, Suffix>>;
+type _ArgsOf<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = SliceInfoArgs<_SliceMap<SlceCls>[Suffix]>;
+type DefaultSliceStateFields<SlceCls extends SliceCls, _RefName extends string, _CapRefName extends string, _Full, _Light extends {
+    id: string;
+}, _Insight, _Default, _Sort> = {
+    [Suffix in keyof _SliceMap<SlceCls> as `default${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Default;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}List${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}ListLoading${_SuffixCap<SlceCls, Suffix>}`]: boolean;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitList${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitAt${_SuffixCap<SlceCls, Suffix>}`]: Date;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Selection${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Insight${_SuffixCap<SlceCls, Suffix>}`]: _Insight;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `lastPageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `pageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `limitOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `queryArgsOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _ArgsOf<SlceCls, Suffix>;
+} & {
+    [Suffix in keyof _SliceMap<SlceCls> as `sortOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Sort;
+};
+export type DefaultState<SlceCls extends SliceCls, _RefName extends SlceCls["srv"]["cnst"]["refName"] = SlceCls["srv"]["cnst"]["refName"], _Full = NonNullable<SlceCls["srv"]["cnst"]>["_Full"], _Light extends {
+    id: string;
+} = SlceCls["srv"]["cnst"]["_Light"], _Insight = SlceCls["srv"]["cnst"]["_Insight"], _Filter extends FilterInstance = SlceCls["srv"]["db"]["_Filter"], _CapitalizedRefName extends string = Capitalize<_RefName>, _Default = SlceCls["srv"]["cnst"]["_Default"], _Sort = SlceCls["srv"]["db"]["_Sort"]> = BaseState<_RefName, _Full, _Default> & DefaultSliceStateFields<SlceCls, _RefName, _CapitalizedRefName, _Full, _Light, _Insight, _Default, _Sort>;
+export declare const createDatabaseState: (refName: string) => {
+    [x: string]: string | boolean | object | null;
+};
+export declare const createSliceState: (refName: string, slice: {
+    [key: string]: SerializedSlice;
+}) => Record<string, unknown>;
+export {};

package/types/store/stateBuilder.d.ts

@@ -0,0 +1,141 @@
+import { type Cls, type EnumInstance, PRIMITIVE_DEFAULT_VALUE, type PrimitiveScalar } from "akanjs/base";
+export type StateInitializer = () => unknown;
+export type StateInitializerMap = Record<string, StateInitializer>;
+export type SearchParamsState = Record<string, string | string[]>;
+export interface PersistSessionMeta {
+    kind: "persist" | "session";
+    key: string;
+    storageKey: string;
+    parse: (value: unknown) => unknown;
+    serialize: (value: unknown) => unknown;
+    getDefault: () => unknown;
+}
+export interface SearchMeta {
+    kind: "search";
+    key: string;
+    paramKey: string;
+    parseSearch: (searchParams: SearchParamsState) => unknown;
+    getDefault: () => unknown;
+}
+export interface ComputedMeta {
+    kind: "computed";
+    key: string;
+    deps: readonly string[];
+    selector: (...values: any[]) => any;
+    equals: (a: any, b: any) => boolean;
+}
+export interface StateDerivedMeta {
+    persistSession: Record<string, PersistSessionMeta>;
+    search: Record<string, SearchMeta>;
+    computed: Record<string, ComputedMeta>;
+    derivedKeys: Set<string>;
+}
+declare const STATE_BUILDER_MARK: unique symbol;
+type Marker = {
+    [STATE_BUILDER_MARK]: true;
+    kind: "persist" | "session";
+    type: any;
+    options: PersistSessionOptions<any>;
+} | {
+    [STATE_BUILDER_MARK]: true;
+    kind: "search";
+    paramKey: string;
+    type: any;
+    options: SearchOptions<any>;
+} | {
+    [STATE_BUILDER_MARK]: true;
+    kind: "computed";
+    deps: readonly string[];
+    selector: (...values: any[]) => any;
+    options: ComputedOptions<any>;
+};
+export interface PersistSessionOptions<T> {
+    default?: T | (() => T);
+    key?: string;
+    nullable?: boolean;
+}
+export interface SearchOptions<T> {
+    default?: T | (() => T);
+    nullable?: boolean;
+}
+export interface ComputedOptions<T> {
+    equals?: (a: T, b: T) => boolean;
+}
+type PrimitiveInput = typeof PrimitiveScalar | StringConstructor | BooleanConstructor | DateConstructor;
+type FieldTypeInput = PrimitiveInput | Cls | EnumInstance | FieldTypeInput[];
+type ValueOfType<T> = T extends readonly (infer V)[] ? ValueOfType<V>[] : T extends {
+    [PRIMITIVE_DEFAULT_VALUE]: infer V;
+} ? V : T extends EnumInstance<any, infer V> ? V : T extends new (...args: any[]) => infer V ? V : any;
+type NullableValue<Value, Options> = Options extends {
+    nullable: true;
+} ? Value | null : Value;
+export type WritableStateOf<State> = {
+    [K in keyof State]: State[K] extends Marker ? MarkerValue<State[K]> : State[K];
+};
+type MarkerValue<M> = M extends {
+    kind: "persist" | "session";
+    type: infer T;
+    options: infer O;
+} ? NullableValue<ValueOfType<T>, O> : M extends {
+    kind: "search";
+    type: infer T;
+    options: infer O;
+} ? NullableValue<ValueOfType<T>, O> : M extends {
+    kind: "computed";
+    selector: (...args: any[]) => infer R;
+} ? R : never;
+export type DerivedStateOf<State> = {
+    [K in keyof State]: State[K] extends Marker ? MarkerValue<State[K]> : never;
+};
+export type DepValues<State, Keys extends readonly (keyof State)[]> = {
+    [I in keyof Keys]: Keys[I] extends keyof State ? State[Keys[I]] : never;
+};
+export interface WritableStateBuilder {
+    persist<T extends FieldTypeInput, Options extends PersistSessionOptions<any>>(type: T, options?: Options): {
+        [STATE_BUILDER_MARK]: true;
+        kind: "persist";
+        type: T;
+        options: Options;
+    };
+    session<T extends FieldTypeInput, Options extends PersistSessionOptions<any>>(type: T, options?: Options): {
+        [STATE_BUILDER_MARK]: true;
+        kind: "session";
+        type: T;
+        options: Options;
+    };
+}
+export interface DerivedStateBuilder<WritableState> {
+    search<T extends FieldTypeInput, Options extends SearchOptions<any>>(paramKey: string, type: T, options?: Options): {
+        [STATE_BUILDER_MARK]: true;
+        kind: "search";
+        paramKey: string;
+        type: T;
+        options: Options;
+    };
+    computed<const Keys extends readonly (keyof WritableState & string)[], Result>(deps: Keys, selector: (...values: DepValues<WritableState, Keys>) => Result, options?: ComputedOptions<Result>): {
+        [STATE_BUILDER_MARK]: true;
+        kind: "computed";
+        deps: Keys;
+        selector: (...values: any[]) => Result;
+        options: ComputedOptions<Result>;
+    };
+}
+export declare const createEmptyDerivedMeta: () => StateDerivedMeta;
+export declare const mergeDerivedMeta: (...metas: (StateDerivedMeta | undefined)[]) => StateDerivedMeta;
+export declare const createWritableStateBuilder: () => WritableStateBuilder;
+export declare const createDerivedStateBuilder: <WritableState>() => DerivedStateBuilder<WritableState>;
+export declare const isStateBuilderMarker: (value: unknown) => value is Marker;
+export declare const createStateInitializerMap: (state: Record<string, unknown>) => StateInitializerMap;
+export declare const evaluateInitializers: (initializers: StateInitializerMap) => Record<string, unknown>;
+export declare const resolveWritableState: (refName: string, state: Record<string, unknown>) => {
+    shape: Record<string, unknown>;
+    initializers: StateInitializerMap;
+    meta: StateDerivedMeta;
+};
+export declare const resolveDerivedState: <WritableState>(state: Record<string, unknown>, writableKeys: Set<string>) => {
+    shape: Record<string, unknown>;
+    meta: StateDerivedMeta;
+};
+export declare const makeDefaultFactory: (value: unknown) => StateInitializer;
+export declare const getSearchParam: (searchParams: SearchParamsState, key: string) => string | undefined;
+export {};