import { Draft, Draft as Draft$1, WritableDraft, nothing, nothing as nothing$1 } from "immer";
import * as type_plus0 from "type-plus";
import { AnyFunction, KeyTypes, RecordValue, UnionOfValues, Widen } from "type-plus";
import * as _just_web_app0 from "@just-web/app";
import { LogGizmo, Logger, define } from "@just-web/app";

//#region src/types.d.ts

/**
 * Updater for type `T`.
 *
 * If the function does not return,
 * or the resulting promise does not resolve to a value,
 * the value is assumed to be updated in-place.
 *
 * If the function returns `nothing` or resolves to `nothing`,
 * the value will be cleared.
 */
type Updater<T$1> = (draft: Draft<T$1>) => UpdaterResult<T$1> | Promise<UpdaterResult<T$1>>;
/**
 * The result of an updater function.
 *
 * If the updater returns `nothing` or resolves to `nothing`,
 * the value will be cleared.
 *
 * If the updater returns a promise that resolves to `nothing`,
 * the value will be cleared.
 *
 * If the updater returns a promise that resolves to a value, the value will be set to the resolved value.
 *
 * The return type cannot narrow to `typeof nothing` due to the limitation of TypeScript.
 * Need to use `symbol` instead.
 */
type UpdaterResult<T$1> = undefined extends T$1 ? Exclude<T$1, undefined> | void | symbol : T$1 | symbol | void;
//#endregion
//#region src/state.d.ts
type SetStateValue<T$1> = T$1 | Updater<T$1>;
/**
 * set or update the state.
 */
type SetState<T$1> = <V extends SetStateValue<T$1> = SetStateValue<T$1>>(value: V) => V extends AnyFunction<any, Promise<any>> ? Promise<T$1> : T$1;
type StateChangeHandler<T$1> = (value: T$1, prev: T$1) => void;
type OnStateChange<T$1> = (handler: StateChangeHandler<T$1>) => () => void;
type ResetState = () => void;
type StateMeta = {
  logger?: Logger;
};
/**
 * creates a functional style state to track changes of a value.
 *
 * @param init initial value T
 * @param meta optional meta data for custom logger.
 * @returns [value: T, set: SetState<T>, onChange: OnStateChange<T>, reset: ResetState]
 *
 * @example
 * ```ts
 * const [value, set, onChange, reset] = app.states.createState(0)
 *
 * value // 0
 * set(1) // value: 1
 * onChange(v => console.log(v)) // trigger when set
 * reset() // reset value to the initial value
 * ```
 */
declare function createState<T$1>(init: T$1, meta?: StateMeta): [value: T$1, set: SetState<T$1>, onChange: OnStateChange<T$1>, reset: ResetState];
//#endregion
//#region src/registry.d.ts
type ReadonlyRegistry<K$1 extends KeyTypes, T$1> = {
  get(): Record<K$1, T$1>;
  onChange: OnStateChange<Record<K$1, T$1>>;
  keys(): K$1[];
  has(key: K$1): boolean;
  size(): number;
  values(): T$1[];
};
type Registry<K$1 extends KeyTypes, T$1> = ReadonlyRegistry<K$1, T$1> & {
  set: SetState<Record<K$1, T$1>>;
  reset: ResetState;
};
/**
 * Gets the Value type of the Registry (the `Record<K, T>`)
 */
type RegistryValue<R extends Registry<any, any>> = ReturnType<R['get']>;
declare function createRegistry<K$1 extends KeyTypes, T$1>(init?: Record<K$1, T$1>, meta?: StateMeta): Registry<Widen<K$1>, T$1>;
declare function toReadonlyRegistry<S extends Registry<any, any>>(registry: S): S extends Registry<infer K, infer T> ? ReadonlyRegistry<K, T> : never;
//#endregion
//#region src/store.d.ts
type ReadonlyStore<T$1> = {
  get(): T$1;
  onChange: OnStateChange<T$1>;
};
/**
 * A store tracks a value and its changes.
 */
type Store<T$1> = ReadonlyStore<T$1> & {
  set: SetState<T$1>;
  reset: ResetState;
};
/**
 * The Store Value type.
 */
type StoreValue<S extends Store<any>> = ReturnType<S['get']>;
/**
 * creates a object style store to track a value and its changes.
 *
 * @param init initial value T
 * @param meta optional meta data for custom logger.
 * @returns { get, set, update, onChange, reset }
 *
 * @example
 * ```ts
 * const store = app.states.createStore(0)
 *
 * store.get() // 0
 * store.set(1) // 1
 * store.update(v => v + 1) // 2
 * store.onChange(v => console.log(v)) // trigger when set or update
 * store.reset() // reset value to the initial value
 * ```
 */
declare function createStore<T$1>(value: T$1, meta?: StateMeta): Store<T$1>;
/**
 * Convert a store to a readonly store.
 */
declare function toReadonlyStore<S extends Store<any>>(store: S): S extends Store<infer T> ? ReadonlyStore<T> : never;
//#endregion
//#region src/adder.d.ts
type Adder<T$1> = (...entries: T$1[]) => void;
type WithAdder<T$1> = {
  add: Adder<T$1>;
};
/**
 * builds an adder function for a store or registry
 */
declare function adder<R extends Registry<any, any>>(registry: R, handler: (record: Draft$1<RegistryValue<R>>, entry: RecordValue<RegistryValue<R>>) => void): Adder<ReturnType<RecordValue<RegistryValue<R>>>>;
declare function adder<A extends Array<any>, S extends Store<A>>(store: S, handler: (record: Draft$1<A>, entry: UnionOfValues<A>) => void): Adder<UnionOfValues<A>>;
declare function adder<S extends Store<Record<KeyTypes, any>>>(store: S, handler: (record: Draft$1<StoreValue<S>>, entry: RecordValue<StoreValue<S>>) => void): Adder<RecordValue<StoreValue<S>>>;
declare function withAdder<R extends Registry<any, any>>(registry: R, addEntry: (record: Draft$1<RegistryValue<R>>, entry: RecordValue<RegistryValue<R>>) => void): R & WithAdder<RecordValue<RegistryValue<R>>>;
declare function withAdder<A extends Array<any>, S extends Store<A>>(store: S, addEntry: (record: Draft$1<A>, entry: ReturnType<S['get']>) => void): S & WithAdder<UnionOfValues<ReturnType<S['get']>>>;
declare function withAdder<S extends Store<Record<any, any>>>(store: S, addEntry: (record: Draft$1<StoreValue<S>>, entry: RecordValue<StoreValue<S>>) => void): S & WithAdder<RecordValue<StoreValue<S>>>;
declare function push<A extends Array<any>>(record: Draft$1<A>, entry: UnionOfValues<A>): void;
declare function unshift<A extends Array<any>>(record: Draft$1<A>, entry: UnionOfValues<A>): void;
//#endregion
//#region src/is_nothing.d.ts
declare function isNothing(value: unknown): value is typeof nothing$1;
//#endregion
//#region src/states_gizmo.d.ts
/**
 * A gizmo that provides states functionalities.
 *
 * It uses `immer` internally to perform state updates.
 *
 * @require LogGizmo
 *
 * @example
 * ```ts
 * const app = await justApp().with(statesGizmo).create()
 *
 * app.states.createState(0)
 * app.states.createStore(0)
 * app.states.createRegistry()
 * ```
 */
declare const statesGizmo: _just_web_app0.GizmoStatic<_just_web_app0.DepBuilder<LogGizmo, unknown>, {
  states: {
    /**
     * creates a functional style state to track changes of a value.
     *
     * By default it will use the app logger.
     *
     * @param init initial value T
     * @param meta optional meta data for custom logger.
     * @returns [value: T, set: SetState<T>, onChange: OnStateChange<T>, reset: ResetState]
     *
     * @example
     * ```ts
     * const [value, set, onChange, reset] = app.states.createState(0)
     *
     * value // 0
     * set(1) // value: 1
     * onChange(v => console.log(v)) // trigger when set
     * reset() // reset value to the initial value
     * ```
     */
    createState<T$1>(init: T$1, meta?: StateMeta): [value: T$1, set: SetState<T$1>, onChange: OnStateChange<T$1>, reset: ResetState];
    /**
     * creates a object style store to track a value and its changes.
     *
     * By default it will use the app logger.
     *
     * @param init initial value T
     * @param meta optional meta data for custom logger.
     * @returns { get, set, update, onChange, reset }
     *
     * @example
     * ```ts
     * const store = app.states.createStore(0)
     *
     * store.get() // 0
     * store.set(1) // 1
     * store.update(v => v + 1) // 2
     * store.onChange(v => console.log(v)) // trigger when set or update
     * store.reset() // reset value to the initial value
     * ```
     */
    createStore<T$1>(init: T$1, meta?: StateMeta): Store<T$1>;
    /**
     * Creates a registry to track a record and its changes.
     * A registry is similar to a `store` but specialized for records.
     *
     * It provides additional methods such as `keys()` and `has()`.
     *
     * By default it will use the app logger.
     *
     * @param init optional initial value T
     * @param meta optional meta data for custom logger.
     * @returns { get, set, update, onChange, reset }
     *
     * @example
     * ```ts
     * const registry = app.states.createRegistry()
     *
     * registry.update(v => { v.x = 1 })
     * registry.keys() // ['x']
     * registry.has('x') // true
     * registry.size() // 1
     * registry.values() // [1]
     * ```
     */
    createRegistry<K$1 extends KeyTypes, T$1>(init?: Record<K$1, T$1>, meta?: StateMeta): Registry<type_plus0.Widen<K$1>, T$1>;
  };
}>;
/**
 * A gizmo that provides states functionalities.
 */
type StatesGizmo = define.Infer<typeof statesGizmo>;
//#endregion
export { Adder, type Draft, OnStateChange, ReadonlyRegistry, ReadonlyStore, Registry, RegistryValue, ResetState, SetState, SetStateValue, StateChangeHandler, StateMeta, StatesGizmo, Store, StoreValue, type Updater, type UpdaterResult, WithAdder, type WritableDraft, adder, createRegistry, createState, createStore, isNothing, nothing, push, statesGizmo, toReadonlyRegistry, toReadonlyStore, unshift, withAdder };
//# sourceMappingURL=index.d.cts.map