akanjs 2.3.5-rc.8 → 2.3.5

package/types/store/baseSt.d.ts

@@ -62,7 +62,7 @@ declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./
     devMode: boolean;
     deviceToken: string;
     currentPath: string;
-}>, any, any, any, any, any, "Base", any, any>;
+}>, any, any, any, any, any, any, any, any>;
 export declare class BaseStore extends BaseStore_base {
     setDevMode(value: boolean): void;
     setWindowSize(): void;
@@ -98,7 +98,36 @@ declare const RootStore_base: import("./rootStore.d.ts").RootStoreCls<"root", im
     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>;
+    [x: `base${Capitalize<string>}`]: {
+        [x: `init${any}`]: (...args: any[]) => Promise<void>;
+    } & {
+        [x: `refresh${any}`]: (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>;
+    } & {
+        [x: `select${any}`]: (model: any, options?: {
+            refresh?: boolean;
+            remove?: boolean;
+        }) => void;
+    } & {
+        [x: `setPageOf${any}`]: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+    } & {
+        [x: `addPageOf${any}`]: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+    } & {
+        [x: `setLimitOf${any}`]: (limit: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+    } & {
+        [x: `setQueryArgsOf${any}`]: (...args: any[] | [setQueryArgs: (...prevQueryArgs: any[]) => any[], options?: import("../common.d.ts").FetchPolicy<unknown> | undefined]) => Promise<void>;
+    } & {
+        [x: `setSortOf${any}`]: (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, any, "", any, any>;
+        set: (setState: Partial<import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>> | ((state: import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>) => void)) => void;
+    };
 }, any>;
 export declare class RootStore extends RootStore_base {
 }
@@ -377,35 +406,35 @@ export declare const st: {
         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>;
+        [x: `base${Capitalize<string>}`]: import("./withSelector.d.ts").SliceSelectors<"base", import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>, {
+            [x: `init${any}`]: (...args: any[]) => Promise<void>;
         } & {
-            refreshBase: (initForm?: (import("akanjs/fetch").FetchInitForm<any, any, import("../base.d.ts").GetStateObject<{
+            [x: `refresh${any}`]: (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?: {
+            [x: `select${any}`]: (model: any, options?: {
                 refresh?: boolean;
                 remove?: boolean;
             }) => void;
         } & {
-            setPageOfBase: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+            [x: `setPageOf${any}`]: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
         } & {
-            addPageOfBase: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+            [x: `addPageOf${any}`]: (page: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
         } & {
-            setLimitOfBase: (limit: number, options?: import("../common.d.ts").FetchPolicy) => Promise<void>;
+            [x: `setLimitOf${any}`]: (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>;
+            [x: `setQueryArgsOf${any}`]: (...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>;
+            [x: `setSortOf${any}`]: (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;
+            get: () => import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>;
+            set: (setState: Partial<import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>> | ((state: import("./state.d.ts").SliceState<"base", "", any, any, any[], any, any, any, "", any, any>) => void)) => void;
         }>;
     };
 };

package/types/store/state.d.ts

@@ -1,9 +1,18 @@
-import { DataList, type SLICE_META } from "akanjs/base";
+import { DataList } 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";
+import type { SerializedSlice, SlceCnstCapitalizedRefName, SlceCnstDefault, SlceCnstFull, SlceCnstInsight, SlceCnstLight, SlceCnstRefName, SlceDbFilter, SlceDbSort, SliceCls } from "akanjs/signal";
+import type { StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap, Submit } from "./types.d.ts";
 export type SliceStateKey = "defaultModel" | "modelInsight" | "modelList" | "modelListLoading" | "modelInitList" | "modelInitAt" | "modelSelection" | "lastPageOfModel" | "pageOfModel" | "limitOfModel" | "queryArgsOfModel" | "sortOfModel";
+type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
+type _StateRefName<S extends SliceCls> = SlceCnstRefName<S>;
+type _StateCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _StateFull<S extends SliceCls> = SlceCnstFull<S>;
+type _StateLight<S extends SliceCls> = SlceCnstLight<S>;
+type _StateInsight<S extends SliceCls> = SlceCnstInsight<S>;
+type _StateDefault<S extends SliceCls> = SlceCnstDefault<S>;
+type _StateFilter<S extends SliceCls> = SlceDbFilter<S>;
+type _StateSort<S extends SliceCls> = SlceDbSort<S>;
 type BaseState<RefName extends string, Full, _Default = DefaultOf<Full>> = {
     [K in RefName]: Full | null;
 } & {
@@ -48,40 +57,28 @@ export type SliceState<RefName extends string, Suffix extends string, Full, Ligh
 } & {
     [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;
+}, _Insight, _Default, _Sort, _Suffixes extends keyof _SliceMap<SlceCls> = keyof _SliceMap<SlceCls>> = {
+    [Suffix in _Suffixes as `default${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: _Default;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}List${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+    [Suffix in _Suffixes as `${_RefName}List${StoreSliceSuffixCap<SlceCls, Suffix>}` | `${_RefName}InitList${StoreSliceSuffixCap<SlceCls, Suffix>}` | `${_RefName}Selection${StoreSliceSuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}ListLoading${_SuffixCap<SlceCls, Suffix>}`]: boolean;
+    [Suffix in _Suffixes as `${_RefName}InitAt${StoreSliceSuffixCap<SlceCls, Suffix>}`]: Date;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitList${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+    [Suffix in _Suffixes as `${_RefName}ListLoading${StoreSliceSuffixCap<SlceCls, Suffix>}`]: boolean;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitAt${_SuffixCap<SlceCls, Suffix>}`]: Date;
+    [Suffix in _Suffixes as `${_RefName}Insight${StoreSliceSuffixCap<SlceCls, Suffix>}`]: _Insight;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Selection${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+    [Suffix in _Suffixes as `lastPageOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}` | `pageOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}` | `limitOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: number;
 } & {
-    [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Insight${_SuffixCap<SlceCls, Suffix>}`]: _Insight;
+    [Suffix in _Suffixes as `queryArgsOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: StoreSliceArgs<SlceCls, Suffix>;
 } & {
-    [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;
+    [Suffix in _Suffixes as `sortOf${_CapRefName}${StoreSliceSuffixCap<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 {
+export type DefaultState<SlceCls extends SliceCls, _RefName extends _StateRefName<SlceCls> = _StateRefName<SlceCls>, _Full = _StateFull<SlceCls>, _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>;
+} = _StateLight<SlceCls>, _Insight = _StateInsight<SlceCls>, _Filter extends FilterInstance = _StateFilter<SlceCls>, _CapitalizedRefName extends string = _StateCap<SlceCls>, _Default = _StateDefault<SlceCls>, _Sort = _StateSort<SlceCls>> = 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;
 };

package/types/store/stateBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type Cls, type EnumInstance, PRIMITIVE_DEFAULT_VALUE, type PrimitiveScalar } from "akanjs/base";
+import { type Cls, DEFAULT_VALUE, type EnumInstance, type PrimitiveScalar } from "akanjs/base";
 export type StateInitializer = () => unknown;
 export type StateInitializerMap = Record<string, StateInitializer>;
 export type SearchParamsState = Record<string, string | string[]>;
@@ -64,7 +64,7 @@ export interface ComputedOptions<T> {
 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;
+    [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;

package/types/store/store.d.ts

@@ -1,16 +1,28 @@
 import { ACTION_META, type Cls, type MergeAllActionTypes, type MergeAllKeyOfObjects, type SLICE_META, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
 import type { FilterInstance } from "akanjs/document";
 import type { ClientSignal } from "akanjs/fetch";
-import type { SerializedSlice, SliceCls } from "akanjs/signal";
+import type { SerializedSlice, SlceCnstCapitalizedRefName, SlceCnstDefault, SlceCnstFull, SlceCnstInput, SlceCnstInsight, SlceCnstLight, SlceDbFilter, SlceDbSort, SliceCls } from "akanjs/signal";
 import { type DefaultAction } from "./action.d.ts";
 import { type DefaultState } from "./state.d.ts";
 import { type DerivedStateBuilder, type DerivedStateOf, type StateDerivedMeta, type StateInitializerMap, type WritableStateBuilder, type WritableStateOf } from "./stateBuilder.d.ts";
-import type { InternalSlice, SetGet, SetGetWritable } from "./types.d.ts";
-export type StoreCls<RefName extends string = string, WritableState = any, Action = unknown, SlceCls extends SliceCls = any, DerivedState = unknown, State = WritableState & DerivedState, _Input = SlceCls["srv"]["cnst"]["_Input"], _Full = SlceCls["srv"]["cnst"]["_Full"], _Light extends {
+import type { InternalSlice, SetGet, SetGetWritable, StoreSliceMap, StoreSliceName, StoreSliceSuffix } from "./types.d.ts";
+type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
+type _StoreInput<S extends SliceCls> = SlceCnstInput<S>;
+type _StoreFull<S extends SliceCls> = SlceCnstFull<S>;
+type _StoreLight<S extends SliceCls> = SlceCnstLight<S>;
+type _StoreInsight<S extends SliceCls> = SlceCnstInsight<S>;
+type _StoreFilter<S extends SliceCls> = SlceDbFilter<S>;
+type _StoreCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _StoreDefault<S extends SliceCls> = SlceCnstDefault<S>;
+type _StoreSort<S extends SliceCls> = SlceDbSort<S>;
+type StoreSliceOf<SlceCls extends SliceCls, RefName extends string, Suffix extends keyof _SliceMap<SlceCls>, Input, 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"]> = Cls<SetGetWritable<WritableState, State> & Action & {
+}, Insight, Filter extends FilterInstance, CapitalizedRefName extends string, Default, Sort> = InternalSlice<_SliceMap<SlceCls>[Suffix], RefName, StoreSliceSuffix<SlceCls, Suffix>, Input, Full, Light, Insight, Filter, CapitalizedRefName, Default, Sort>;
+export type StoreCls<RefName extends string = string, WritableState = any, Action = unknown, SlceCls extends SliceCls = any, DerivedState = unknown, State = WritableState & DerivedState, _Input = _StoreInput<SlceCls>, _Full = _StoreFull<SlceCls>, _Light extends {
+    id: string;
+} = _StoreLight<SlceCls>, _Insight = _StoreInsight<SlceCls>, _Filter extends FilterInstance = _StoreFilter<SlceCls>, _CapitalizedRefName extends string = _StoreCap<SlceCls>, _Default = _StoreDefault<SlceCls>, _Sort = _StoreSort<SlceCls>> = Cls<SetGetWritable<WritableState, State> & Action & {
     slice: {
-        [Suffix in keyof SlceCls[typeof SLICE_META] as Suffix extends string ? `${RefName}${Capitalize<Suffix>}` : never]: InternalSlice<SlceCls[typeof SLICE_META][Suffix], RefName, Suffix & string, _Input, _Full, _Light, _Insight, _Filter, _CapitalizedRefName, _Default, _Sort>;
+        [Suffix in keyof _SliceMap<SlceCls> as Suffix extends string ? StoreSliceName<RefName, Suffix> : never]: StoreSliceOf<SlceCls, RefName, Suffix, _Input, _Full, _Light, _Insight, _Filter, _CapitalizedRefName, _Default, _Sort>;
     };
 }, {
     readonly type: "module";

package/types/store/types.d.ts

@@ -1,6 +1,7 @@
+import type { SLICE_META } from "akanjs/base";
 import type { DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
-import type { SliceInfo } from "akanjs/signal";
+import type { SliceCls, SliceInfo, SliceInfoArgs } from "akanjs/signal";
 import type { SliceAction } from "./action.d.ts";
 import type { SliceState } from "./state.d.ts";
 export interface Submit {
@@ -29,7 +30,12 @@ export interface SetPick<State = any> {
 export type Get<State, Actions> = {
     get: () => State & Actions;
 };
-export type SliceStateAction<RefName extends string = string, Suffix extends string = "", SliceName extends string = `${RefName}${Capitalize<Suffix>}`, State = any, Action = any> = Action & {
+export type StoreSliceMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
+export type StoreSliceSuffix<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = Suffix & string;
+export type StoreSliceSuffixCap<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = Capitalize<StoreSliceSuffix<SlceCls, Suffix>>;
+export type StoreSliceArgs<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = SliceInfoArgs<StoreSliceMap<SlceCls>[Suffix]>;
+export type StoreSliceName<RefName extends string, Suffix extends string> = `${RefName}${Capitalize<Suffix>}`;
+export type SliceStateAction<RefName extends string = string, Suffix extends string = "", SliceName extends string = StoreSliceName<RefName, Suffix>, State = any, Action = any> = Action & {
     refName: RefName;
     suffix: Suffix;
     sliceName: SliceName;
@@ -38,5 +44,5 @@ export type SliceStateAction<RefName extends string = string, Suffix extends str
 };
 export type InternalSlice<SlceInfo extends SliceInfo = any, RefName extends string = any, Suffix extends string = any, Input = any, Full = any, Light extends {
     id: string;
-} = any, Insight = any, Filter extends FilterInstance = any, _CapitalizedRefName extends string = Capitalize<RefName>, _Default = DefaultOf<Full>, _Sort = ExtractSort<Filter>, _Args extends any[] = SlceInfo extends SliceInfo<any, any, any, any, any, any, any, any, infer Args, any, any> ? Args : never, _SliceState = SliceState<RefName, "", Full, Light, _Args, Insight, Filter, _CapitalizedRefName, "", _Default, _Sort>, _SliceAction = SliceAction<RefName, "", Input, Light, _Args, Filter, _CapitalizedRefName, "", _Sort>> = SliceStateAction<RefName, Suffix, `${RefName}${Capitalize<Suffix>}`, _SliceState, _SliceAction>;
+} = any, Insight = any, Filter extends FilterInstance = any, _CapitalizedRefName extends string = Capitalize<RefName>, _Default = DefaultOf<Full>, _Sort = ExtractSort<Filter>, _Args extends any[] = SliceInfoArgs<SlceInfo>, _SliceState = SliceState<RefName, "", Full, Light, _Args, Insight, Filter, _CapitalizedRefName, "", _Default, _Sort>, _SliceAction = SliceAction<RefName, "", Input, Light, _Args, Filter, _CapitalizedRefName, "", _Sort>, _SliceName extends string = StoreSliceName<RefName, Suffix>> = SliceStateAction<RefName, Suffix, _SliceName, _SliceState, _SliceAction>;
 export {};

package/ui/Signal/makeExample.ts

@@ -2,9 +2,9 @@ import {
   Any,
   arraiedModel,
   type Cls,
+  EXAMPLE_VALUE,
   FIELD_META,
   getNonArrayModel,
-  PRIMITIVE_EXAMPLE_VALUE,
   PrimitiveRegistry,
   type PrimitiveScalar,
 } from "akanjs/base";
@@ -15,7 +15,7 @@ import type { SerializedArg, SerializedEndpoint, SignalType } from "akanjs/signa
 const getResponseExample = (ref: Cls | Cls[]) => {
   const [modelRef, arrDepth] = getNonArrayModel(ref);
   const isPrimitive = PrimitiveRegistry.has(modelRef);
-  if (isPrimitive) return arraiedModel((modelRef as typeof PrimitiveScalar)[PRIMITIVE_EXAMPLE_VALUE], arrDepth);
+  if (isPrimitive) return arraiedModel((modelRef as typeof PrimitiveScalar)[EXAMPLE_VALUE], arrDepth);
 
   const example: Record<string, unknown> = {};
   Object.entries((modelRef as ConstantCls)[FIELD_META]).forEach(([key, field]) => {
@@ -30,7 +30,7 @@ const getResponseExample = (ref: Cls | Cls[]) => {
 const getRequestExample = (modelRef: Cls) => {
   const example: Record<string, unknown> = {};
   const isPrimitive = PrimitiveRegistry.has(modelRef);
-  if (isPrimitive) return (modelRef as typeof PrimitiveScalar)[PRIMITIVE_EXAMPLE_VALUE];
+  if (isPrimitive) return (modelRef as typeof PrimitiveScalar)[EXAMPLE_VALUE];
   else {
     Object.entries((modelRef as ConstantCls)[FIELD_META]).forEach(([key, field]) => {
       if (!field.isScalar && field.isClass) example[key] = "ObjectID";