@qundus/qstate/dist/index-B-auO4kZ.d.cts

your everyday state pal

import { BaseDeepMap, DeepMapStore, MapStore, PreinitializedWritableAtom, WritableAtom, ReadableAtom, StoreValue } from 'nanostores';
import { isServerSide as export_default } from './checks/index.cjs';
import { UseStoreOptions } from '@nanostores/preact';
import { ReactHook } from './integrations/react/_model.cjs';
import { SolidHook, SolidHookUnwrapped, SolidHookFrom, SolidHookFromUnwrapped } from './integrations/solid/_model.cjs';
import { VanillaHook } from './integrations/vanilla/_model.cjs';
import { VueHook } from './integrations/vue/_model.cjs';
import { PersistentEncoder, PersistentSimpleOptions } from '@nanostores/persistent';

type AddonAstroIntegration<S extends NanoAnyStore> = {
    middleware: (ctx: any) => NanoStoreValue<S>;
    set: (value: NanoStoreValue<S>, actions?: any) => Promise<void>;
};
/**
 * extra functionality for astrojs framework
 */
declare const astroIntegrationAddon: _AddonFactory<AddonAstroIntegration<NanoAnyStore>, {
    name: string;
}>;

type AddonChecks = {
    isServerSide: typeof export_default;
};
declare const checksAddon: _AddonFactory<AddonChecks>;

type OptionPersistOptionsIn = boolean | "pass-down";
type OptionPersistOptionsOut<S extends NanoAnyStore | NanoReadable, O extends Options<Extract<S, NanoAnyStore>> | OptionsDerived> = InferOptionKeyValue<O, "persistOptions"> extends {
    options: infer options;
    value: infer value;
} ? false extends options ? unknown : true extends IsUnknown<value> | IsUndefined<value> | IsNull<value> | IsEmpty<value> ? object : {
    readonly __options: "pass-down" extends value ? O : Omit<O, "persistOptions">;
} : never;
type OptionsSetup<S extends NanoAnyStore> = Pick<Exclude<Options<S>, undefined>, "addons" | "hooks" | "events"> | undefined;
type MergedOptions<S extends NanoAnyStore, D extends Options<S>, G extends OptionsSetup<S>> = G extends Exclude<G, undefined> ? D extends Exclude<D, undefined> ? {
    addons: G["addons"] & D["addons"];
    hooks: G["hooks"] & D["hooks"];
    events: G["events"] & D["events"];
    persistOptions: D["persistOptions"];
} : G : D;
type MergedOptionsDerived<S extends NanoAnyStore | NanoReadable, D extends OptionsDerived, G extends Options<Extract<NanoAnyStore, S>> | OptionsDerived> = G extends Exclude<G, undefined> ? D extends Exclude<D, undefined> ? {
    hooks: IsUnknown<D["hooks"]> extends true ? G["hooks"] : G["hooks"] & D["hooks"];
    events: G extends Options<infer Store> ? D["events"] : G["events"] & D["events"];
    persistOptions: IsUnknown<D["persistOptions"]> extends true ? G["persistOptions"] : D["persistOptions"];
} extends infer L ? Extract<L, OptionsDerived> : never : G : D;

type AddonDerive<S extends NanoAnyStore, O extends Options<S>> = <R, D extends OptionsDerived>(func: (value: NanoStoreValue<S>) => R, _options?: D) => StoreDerived<R, MergedOptionsDerived<S, D, O>>;
/**
 * this addon uses deriveFrom offered by stores.derivations, it will internally adjust
 * options.persistOptions if it's not set or if it's set to false to allow passing options
 * to children/derivatives
 * @returns derived store based on this store's options;
 */
declare const deriveAddon: _AddonFactory<AddonDerive<NanoAnyStore, Options<NanoAnyStore>>>;

/**
 * unlike get, this gets the value after creating completely new value that helps
 * guarantees state notifying after using state.set with it.
 */
type AddonGetNew<S extends NanoAnyStore> = () => NanoStoreValue<S>;
declare const getNewAddon: _AddonFactory<AddonGetNew<NanoAnyStore>>;

/**
 * update store value, no need to set outer value to invoke reactivity.
 * use abort to cancel updates from within function, it throws an error
 * that is caught and returned
 * @example
 * const $state = atom("qstate")
 * const err_update = $state.actions.update(({$next, abort}) => {
 *  if ($next == null) {
 *   abort();
 *  }
 *  return $next + " awesome"
 * })
 */
type AddonUpdate<S extends NanoAnyStore> = (func: (props: {
    $next: NanoStoreValue<S>;
    prev: NanoStoreValue<S>;
    abort: () => void;
}) => NanoStoreValue<S>) => null | {
    message: any;
};
declare const updateAddon: _AddonFactory<AddonUpdate<NanoAnyStore>>;

type _AddonFactory<R, Y extends Record<string, unknown> = {}, S extends NanoAnyStore & Partial<Y> = NanoAnyStore & Partial<Y>, O extends Options<S> = Options<S>> = (state: S, options: O) => R;
type OptionAddonsIn = undefined | {
    [x: string]: _AddonFactory<{}>;
};
type OptionAddonsOut<S extends NanoAnyStore, O extends Options<S>> = InferOptionKeyValue<O, "addons"> extends {
    options: infer options;
    value: infer value;
} ? false extends options ? unknown : true extends IsUnknown<value> | IsUndefined<value> | IsNull<value> | IsEmpty<value> ? unknown : {
    [K in keyof value]: value[K] extends _AddonFactory<infer G, infer added> ? G extends AddonUpdate<any> ? AddonUpdate<S> : G extends AddonDerive<any, any> ? AddonDerive<S, O> : G extends AddonGetNew<any> ? AddonGetNew<S> : G extends AddonAstroIntegration<any> ? AddonAstroIntegration<S> : AddonChecks : never;
} : never;

type EventOnChangeSetupProps = EventOnChangeProps<NanoAnyStore> & {
    /**
     * some extra helpful infor for the setup
     */
    setup: {
        /**
         * DO NOT CALL THIS, this is the internal parent function to be called from within onSet,
         * if called it will cause infinite loop and possible maximum stack
         *
         */
        parent: (props: EventOnChangeSetupProps) => void;
        stateCount: number;
        funcCount: number;
    };
};
type EventOnChangeProps<S extends NanoAnyStore> = {
    $next: {
        abort(): void;
        changed: IsMapStore<S> extends false ? undefined : keyof NanoStoreValue<S>;
        newValue: NanoStoreValue<S>;
        shared: never;
    };
    prev: NanoStoreValue<S>;
    serverSide: boolean;
};
type EventOnChange<S extends NanoAnyStore> = (func: (props: EventOnChangeProps<S>) => void) => void;
declare const onChangeEventSetup: (func: (props: EventOnChangeSetupProps) => void) => AbstractEvent<EventOnChange<NanoAnyStore>>;
declare const onChangeEvent: AbstractEvent<EventOnChange<NanoAnyStore>>;

type EventOnMountOptions = {
    /**
     * default behavior is to return child's function return,
     * this overrides that and prefers setup (this) function return
     * @default false
     */
    overrideChildReturn?: boolean;
    /**
     * call the mount on the first state mount only and not on every state mount
     * @default true
     */
    firstMountOnly?: boolean;
};
type EventOnMountSetupProps = EventOnMountProps<NanoAnyStore> & {
    /**
     * some extra helpful infor for the setup
     */
    setup: {
        /**
         * DO NOT CALL THIS, this is the internal parent function to be called from within onSet,
         * if called it will cause infinite loop and possible maximum stack
         *
         */
        readonly parent: (props: EventOnMountSetupProps) => void | (() => void) | Promise<void | (() => void)>;
        stateCount: number;
        funcCount: number;
        readonly options: EventOnMountOptions;
    };
};
type EventOnMountProps<S extends NanoAnyStore> = {
    state: S;
    serverSide: boolean;
    shared: never;
};
type EventOnMount<S extends NanoAnyStore> = (func: (props: EventOnMountProps<S>) => void | (() => void) | Promise<void | (() => void)>) => void;
declare const onMountEventSetup: (func: (props: EventOnMountSetupProps) => void, options?: EventOnMountOptions) => AbstractEvent<EventOnMount<NanoAnyStore>>;
declare const onMountEvent: AbstractEvent<EventOnMount<NanoAnyStore>>;

type AbstractEvent<Returns, Args extends any[] = any[], S extends NanoAnyStore = NanoAnyStore, O extends Options<S> = Options<S>> = (state: S, options: O, ...args: Args) => Returns;
type OptionEventsIn = undefined | Record<string, <S extends NanoAnyStore, O extends Options<S>>(state: S, options: O) => any>;
type OptionEventsOut<S extends NanoAnyStore, O extends Options<S>> = InferOptionKeyValue<O, "events"> extends {
    options: infer options;
    value: infer value;
} ? false extends options ? unknown : true extends IsUnknown<value> | IsEmpty<value> ? unknown : {
    on: true extends IsUndefined<value> | IsNull<value> ? unknown : {
        [K in keyof value]: value[K] extends AbstractEvent<infer G> ? G extends EventOnChange<any> ? EventOnChange<S> : G extends EventOnMount<any> ? EventOnMount<S> : G : unknown;
    };
} : never;

type PreactHook<S extends NanoAnyStore | NanoReadable> = (options?: UseStoreOptions<S>) => NanoStoreValue<S>;

type SvelteHook<T = any> = () => NanoReadable<T>;

declare const HOOKS_NAMES: {
    readonly preact: "PREACT";
    readonly react: "REACT";
    readonly solid: "SOLID";
    readonly solid_unwrapped: "SOLID-UNWRAPPED";
    readonly solid_from: "SOLID-FROM";
    readonly solid_from_unwrapped: "SOLID-FROM-UNWRAPPED";
    readonly svelte: "SVELTE";
    readonly vanilla: "VANILLA";
    readonly vue: "VUE";
};
declare const HOOK_NAME_KEY: "hookName";

type HookNameKey = typeof HOOK_NAME_KEY;
type HookNames = (typeof HOOKS_NAMES)[keyof typeof HOOKS_NAMES];
type _HookFactory<H extends HookNames, R, S extends NanoAnyStore | NanoReadable = NanoAnyStore | NanoReadable> = (state: S) => R & {
    [HOOK_NAME_KEY]: H;
};
type HookNameValues = (typeof HOOKS_NAMES)[keyof typeof HOOKS_NAMES];
type HooksInUse = {
    hookNames: typeof HOOKS_NAMES;
    hasHooks: boolean;
    hooksUsed: {
        [K in HookNames]?: {
            key: string;
        };
    };
    getHook: (name: HookNames) => string | false;
    getHooks: (...names: HookNames[]) => string[] | false;
};
type OptionHooksIn = undefined | {
    [x: string]: <S extends NanoReadable>(state: S) => () => any;
};
type OptionHooksOut<S extends NanoAnyStore | NanoReadable, O extends Options<Extract<S, NanoAnyStore>> | OptionsDerived, T = NanoStoreValue<S>> = InferOptionKeyValue<O, "hooks"> extends {
    options: infer options;
    value: infer value;
} ? false extends options ? unknown : true extends IsUnknown<value> | IsEmpty<value> ? unknown : {
    hooks: true extends IsUndefined<value> | IsNull<value> ? unknown : {
        [K in keyof value]: value[K] extends _HookFactory<infer name, infer type> ? name extends typeof HOOKS_NAMES.preact ? PreactHook<S> : name extends typeof HOOKS_NAMES.react ? ReactHook<T> : name extends typeof HOOKS_NAMES.solid ? SolidHook<T> : name extends typeof HOOKS_NAMES.solid_unwrapped ? SolidHookUnwrapped<T> : name extends typeof HOOKS_NAMES.solid_from ? SolidHookFrom<T> : name extends typeof HOOKS_NAMES.solid_from_unwrapped ? SolidHookFromUnwrapped<T> : name extends typeof HOOKS_NAMES.svelte ? SvelteHook<T> : name extends typeof HOOKS_NAMES.vanilla ? VanillaHook<T> : name extends typeof HOOKS_NAMES.vue ? VueHook<T> : never : unknown;
    };
} : never;

type OptionsPersistent<T> = Options<NanoPersistent<T>> & {
    encode?: PersistentEncoder<T>["encode"];
    decode?: PersistentEncoder<T>["decode"];
    listen?: PersistentSimpleOptions["listen"];
};
type OptionsPersistentSetup = OptionsSetup<NanoAnyStore> & {
    encode?: PersistentEncoder<any>["encode"];
    decode?: PersistentEncoder<any>["decode"];
    listen?: PersistentSimpleOptions["listen"];
};
type OptionsPersistentToOptions<O extends Options<NanoAnyStore>> = {
    [K in keyof O as K extends keyof Options<any> ? K : never]: O[K];
} extends infer G ? {
    [K in keyof G]: G[K];
} : never;

type _OptionProcessorFactory<Y extends Record<string, unknown> = {}, S extends (NanoAnyStore | NanoReadable) & Partial<Y> = (NanoAnyStore | NanoReadable) & Partial<Y>, O extends Options<Extract<S, NanoAnyStore>> = Options<Extract<S, NanoAnyStore>>, D extends OptionsDerived = OptionsDerived> = (state: S, options: O, derivedOptions?: D) => void;
type TypeMapObject = object;
type TypeDeepMapObject = BaseDeepMap;
type TypeAny = TypeMapObject | TypeDeepMapObject | any;
type NanoAtom<T = TypeAny> = PreinitializedWritableAtom<T> & object;
type NanoPersistent<T = TypeAny> = WritableAtom<T>;
type NanoMap<T extends TypeMapObject = TypeMapObject> = MapStore<T>;
type NanoDeepMap<T extends TypeDeepMapObject = TypeDeepMapObject> = DeepMapStore<T>;
type NanoReadable<T = TypeAny> = ReadableAtom<T>;
type NanoDerived<T = TypeAny> = NanoReadable<T>;
type NanoWritable<T = TypeAny> = WritableAtom<T>;
type NanoAnyStore<T extends TypeAny = TypeAny> = NanoDeepMap<T & TypeDeepMapObject> | NanoDeepMap<TypeDeepMapObject> | NanoMap<T & TypeMapObject> | NanoMap<TypeMapObject> | NanoAtom<T> | NanoPersistent<T>;
type NanoStoreAbstract<T = any> = {
    get(): T;
    readonly value: T | undefined;
};
type NanoStoreValue<S extends NanoStoreAbstract> = StoreValue<S>;
type NanoStoreValues<Stores extends NanoStoreAbstract[]> = {
    [Index in keyof Stores]: StoreValue<Stores[Index]>;
};
type IsMapStore<S extends NanoAnyStore> = S extends MapStore ? true : false;
type IsUnknown<T> = unknown extends T ? true : false;
type IsUndefined<T> = unknown extends T ? never : undefined extends T ? true : false;
type IsNull<T> = unknown extends T ? never : null extends T ? true : false;
type IsEmpty<T> = unknown extends T ? never : {} extends T ? true : false;
type InferOptionKeyValue<O extends Options<NanoAnyStore> | OptionsDerived, Key extends keyof Exclude<O, undefined>> = {
    options: true extends IsUndefined<O> | IsEmpty<O> ? false : true;
    value: Key extends keyof O ? O[Key] : unknown;
};
type Options<S extends NanoAnyStore> = undefined | {
    addons?: OptionAddonsIn;
    events?: OptionEventsIn;
    hooks?: OptionHooksIn;
    persistOptions?: OptionPersistOptionsIn;
};
type OptionsDerived = undefined | {
    hooks?: OptionHooksIn;
    events?: {
        onError?: (error: unknown) => void;
    };
    persistOptions?: OptionPersistOptionsIn;
};
type Store<S extends NanoAnyStore, O extends Options<NanoAnyStore> = Options<NanoAnyStore>> = S & (OptionAddonsOut<S, O> & OptionHooksOut<S, O> & OptionEventsOut<S, O> & OptionPersistOptionsOut<S, O>);
type StoreWithOptions = Store<NanoAnyStore, Options<NanoAnyStore>> & {
    __options: any;
};
type StoreDerived<G, O extends OptionsDerived = OptionsDerived> = NanoReadable<G> & OptionHooksOut<NanoReadable<G>, O> & OptionPersistOptionsOut<NanoReadable<G>, O>;
type StoreDerivedWithOptions = (Store<NanoAnyStore, Options<NanoAnyStore>> & StoreDerived<any, OptionsDerived>) & {
    __options: any;
} extends infer G ? G : never;

type _model_AbstractEvent<Returns, Args extends any[] = any[], S extends NanoAnyStore = NanoAnyStore, O extends Options<S> = Options<S>> = AbstractEvent<Returns, Args, S, O>;
type _model_HookNameKey = HookNameKey;
type _model_HookNameValues = HookNameValues;
type _model_HookNames = HookNames;
type _model_HooksInUse = HooksInUse;
type _model_InferOptionKeyValue<O extends Options<NanoAnyStore> | OptionsDerived, Key extends keyof Exclude<O, undefined>> = InferOptionKeyValue<O, Key>;
type _model_IsEmpty<T> = IsEmpty<T>;
type _model_IsMapStore<S extends NanoAnyStore> = IsMapStore<S>;
type _model_IsNull<T> = IsNull<T>;
type _model_IsUndefined<T> = IsUndefined<T>;
type _model_IsUnknown<T> = IsUnknown<T>;
type _model_MergedOptions<S extends NanoAnyStore, D extends Options<S>, G extends OptionsSetup<S>> = MergedOptions<S, D, G>;
type _model_MergedOptionsDerived<S extends NanoAnyStore | NanoReadable, D extends OptionsDerived, G extends Options<Extract<NanoAnyStore, S>> | OptionsDerived> = MergedOptionsDerived<S, D, G>;
type _model_NanoAnyStore<T extends TypeAny = TypeAny> = NanoAnyStore<T>;
type _model_NanoAtom<T = TypeAny> = NanoAtom<T>;
type _model_NanoDeepMap<T extends TypeDeepMapObject = TypeDeepMapObject> = NanoDeepMap<T>;
type _model_NanoDerived<T = TypeAny> = NanoDerived<T>;
type _model_NanoMap<T extends TypeMapObject = TypeMapObject> = NanoMap<T>;
type _model_NanoPersistent<T = TypeAny> = NanoPersistent<T>;
type _model_NanoReadable<T = TypeAny> = NanoReadable<T>;
type _model_NanoStoreAbstract<T = any> = NanoStoreAbstract<T>;
type _model_NanoStoreValue<S extends NanoStoreAbstract> = NanoStoreValue<S>;
type _model_NanoStoreValues<Stores extends NanoStoreAbstract[]> = NanoStoreValues<Stores>;
type _model_NanoWritable<T = TypeAny> = NanoWritable<T>;
type _model_OptionAddonsIn = OptionAddonsIn;
type _model_OptionAddonsOut<S extends NanoAnyStore, O extends Options<S>> = OptionAddonsOut<S, O>;
type _model_OptionEventsIn = OptionEventsIn;
type _model_OptionEventsOut<S extends NanoAnyStore, O extends Options<S>> = OptionEventsOut<S, O>;
type _model_OptionHooksIn = OptionHooksIn;
type _model_OptionHooksOut<S extends NanoAnyStore | NanoReadable, O extends Options<Extract<S, NanoAnyStore>> | OptionsDerived, T = NanoStoreValue<S>> = OptionHooksOut<S, O, T>;
type _model_OptionPersistOptionsIn = OptionPersistOptionsIn;
type _model_OptionPersistOptionsOut<S extends NanoAnyStore | NanoReadable, O extends Options<Extract<S, NanoAnyStore>> | OptionsDerived> = OptionPersistOptionsOut<S, O>;
type _model_Options<S extends NanoAnyStore> = Options<S>;
type _model_OptionsDerived = OptionsDerived;
type _model_OptionsPersistent<T> = OptionsPersistent<T>;
type _model_OptionsPersistentSetup = OptionsPersistentSetup;
type _model_OptionsPersistentToOptions<O extends Options<NanoAnyStore>> = OptionsPersistentToOptions<O>;
type _model_OptionsSetup<S extends NanoAnyStore> = OptionsSetup<S>;
type _model_Store<S extends NanoAnyStore, O extends Options<NanoAnyStore> = Options<NanoAnyStore>> = Store<S, O>;
type _model_StoreDerived<G, O extends OptionsDerived = OptionsDerived> = StoreDerived<G, O>;
type _model_StoreDerivedWithOptions = StoreDerivedWithOptions;
type _model_StoreWithOptions = StoreWithOptions;
type _model_TypeAny = TypeAny;
type _model_TypeDeepMapObject = TypeDeepMapObject;
type _model_TypeMapObject = TypeMapObject;
type _model__AddonFactory<R, Y extends Record<string, unknown> = {}, S extends NanoAnyStore & Partial<Y> = NanoAnyStore & Partial<Y>, O extends Options<S> = Options<S>> = _AddonFactory<R, Y, S, O>;
type _model__HookFactory<H extends HookNames, R, S extends NanoAnyStore | NanoReadable = NanoAnyStore | NanoReadable> = _HookFactory<H, R, S>;
type _model__OptionProcessorFactory<Y extends Record<string, unknown> = {}, S extends (NanoAnyStore | NanoReadable) & Partial<Y> = (NanoAnyStore | NanoReadable) & Partial<Y>, O extends Options<Extract<S, NanoAnyStore>> = Options<Extract<S, NanoAnyStore>>, D extends OptionsDerived = OptionsDerived> = _OptionProcessorFactory<Y, S, O, D>;
declare namespace _model {
  export type { _model_AbstractEvent as AbstractEvent, _model_HookNameKey as HookNameKey, _model_HookNameValues as HookNameValues, _model_HookNames as HookNames, _model_HooksInUse as HooksInUse, _model_InferOptionKeyValue as InferOptionKeyValue, _model_IsEmpty as IsEmpty, _model_IsMapStore as IsMapStore, _model_IsNull as IsNull, _model_IsUndefined as IsUndefined, _model_IsUnknown as IsUnknown, _model_MergedOptions as MergedOptions, _model_MergedOptionsDerived as MergedOptionsDerived, _model_NanoAnyStore as NanoAnyStore, _model_NanoAtom as NanoAtom, _model_NanoDeepMap as NanoDeepMap, _model_NanoDerived as NanoDerived, _model_NanoMap as NanoMap, _model_NanoPersistent as NanoPersistent, _model_NanoReadable as NanoReadable, _model_NanoStoreAbstract as NanoStoreAbstract, _model_NanoStoreValue as NanoStoreValue, _model_NanoStoreValues as NanoStoreValues, _model_NanoWritable as NanoWritable, _model_OptionAddonsIn as OptionAddonsIn, _model_OptionAddonsOut as OptionAddonsOut, _model_OptionEventsIn as OptionEventsIn, _model_OptionEventsOut as OptionEventsOut, _model_OptionHooksIn as OptionHooksIn, _model_OptionHooksOut as OptionHooksOut, _model_OptionPersistOptionsIn as OptionPersistOptionsIn, _model_OptionPersistOptionsOut as OptionPersistOptionsOut, _model_Options as Options, _model_OptionsDerived as OptionsDerived, _model_OptionsPersistent as OptionsPersistent, _model_OptionsPersistentSetup as OptionsPersistentSetup, _model_OptionsPersistentToOptions as OptionsPersistentToOptions, _model_OptionsSetup as OptionsSetup, _model_Store as Store, _model_StoreDerived as StoreDerived, _model_StoreDerivedWithOptions as StoreDerivedWithOptions, _model_StoreWithOptions as StoreWithOptions, _model_TypeAny as TypeAny, _model_TypeDeepMapObject as TypeDeepMapObject, _model_TypeMapObject as TypeMapObject, _model__AddonFactory as _AddonFactory, _model__HookFactory as _HookFactory, _model__OptionProcessorFactory as _OptionProcessorFactory };
}

export { updateAddon as $, type IsUnknown as A, type IsNull as B, type _AddonFactory as C, type AddonUpdate as D, type AddonDerive as E, type AddonGetNew as F, type AddonAstroIntegration as G, type HooksInUse as H, type IsUndefined as I, type AddonChecks as J, type AbstractEvent as K, type EventOnChange as L, type MergedOptions as M, type NanoStoreAbstract as N, type OptionHooksIn as O, type PreactHook as P, type EventOnMount as Q, _model as R, type SvelteHook as S, type TypeDeepMapObject as T, astroIntegrationAddon as U, type OptionAddonsIn as V, type OptionAddonsOut as W, checksAddon as X, deriveAddon as Y, getNewAddon as Z, type _HookFactory as _, type HookNameKey as a, type OptionEventsIn as a0, type OptionEventsOut as a1, type EventOnChangeSetupProps as a2, type EventOnChangeProps as a3, onChangeEventSetup as a4, onChangeEvent as a5, type EventOnMountOptions as a6, type EventOnMountSetupProps as a7, type EventOnMountProps as a8, onMountEventSetup as a9, onMountEvent as aa, type HookNames as b, type HookNameValues as c, type OptionHooksOut as d, type OptionsSetup as e, type NanoAnyStore as f, type Options as g, type OptionsDerived as h, type NanoReadable as i, type MergedOptionsDerived as j, type StoreWithOptions as k, type OptionPersistOptionsIn as l, type OptionPersistOptionsOut as m, type NanoAtom as n, type Store as o, type NanoDeepMap as p, type NanoStoreValue as q, type StoreDerived as r, type NanoStoreValues as s, type StoreDerivedWithOptions as t, type TypeMapObject as u, type NanoMap as v, type OptionsPersistent as w, type NanoPersistent as x, type OptionsPersistentSetup as y, type IsEmpty as z };