akanjs 2.3.5-rc.8 → 2.3.5

package/types/base/primitiveRegistry.d.ts

@@ -1,4 +1,5 @@
 import dayjsLib, { type Dayjs } from "dayjs";
+import { CLIENT_VALUE, DEFAULT_VALUE, EXAMPLE_VALUE, PURIFIED_VALUE, SERVER_VALUE } from "./symbols.d.ts";
 import type { Cls } from "./types.d.ts";
 export type { Dayjs };
 /** Shared dayjs factory re-export used by Akan documents, services, stores, and UI. */
@@ -16,17 +17,14 @@ export declare class PrimitiveRegistry {
     static getNames(): string[];
     static getAll(): (typeof PrimitiveScalar)[];
 }
-export declare const PRIMITIVE_SERVER_VALUE: unique symbol;
-export declare const PRIMITIVE_CLIENT_VALUE: unique symbol;
-export declare const PRIMITIVE_DEFAULT_VALUE: unique symbol;
-export declare const PRIMITIVE_EXAMPLE_VALUE: unique symbol;
 export type PrimitiveValue = string | number | boolean | Dayjs | Date | null | undefined;
 export declare class PrimitiveScalar {
     static refName: string;
-    static [PRIMITIVE_SERVER_VALUE]: unknown;
-    static [PRIMITIVE_CLIENT_VALUE]: unknown;
-    static [PRIMITIVE_DEFAULT_VALUE]: unknown;
-    static [PRIMITIVE_EXAMPLE_VALUE]: unknown;
+    static [SERVER_VALUE]: unknown;
+    static [CLIENT_VALUE]: unknown;
+    static [DEFAULT_VALUE]: unknown;
+    static [PURIFIED_VALUE]: unknown;
+    static [EXAMPLE_VALUE]: unknown;
     static validate(value: PrimitiveValue): boolean;
     static parseValue(value: PrimitiveValue): PrimitiveValue;
     static serializeValue(value: PrimitiveValue): PrimitiveValue;
@@ -43,10 +41,11 @@ export declare class PrimitiveScalar {
 /** Integer primitive scalar. Accepts safe integer numbers after parsing. */
 export declare class Int extends PrimitiveScalar {
     static refName: "Int";
-    static [PRIMITIVE_SERVER_VALUE]: number;
-    static [PRIMITIVE_CLIENT_VALUE]: number;
-    static [PRIMITIVE_DEFAULT_VALUE]: number;
-    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static [SERVER_VALUE]: number;
+    static [CLIENT_VALUE]: number;
+    static [DEFAULT_VALUE]: number;
+    static [PURIFIED_VALUE]: number;
+    static [EXAMPLE_VALUE]: number;
     static validate(value: string | number): boolean;
     static parseValue(input: string | number): number;
     static serializeValue(value: number): number;
@@ -54,10 +53,11 @@ export declare class Int extends PrimitiveScalar {
 /** Floating point primitive scalar. Accepts finite numbers after parsing. */
 export declare class Float extends PrimitiveScalar {
     static refName: "Float";
-    static [PRIMITIVE_SERVER_VALUE]: number;
-    static [PRIMITIVE_CLIENT_VALUE]: number;
-    static [PRIMITIVE_DEFAULT_VALUE]: number;
-    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static [SERVER_VALUE]: number;
+    static [CLIENT_VALUE]: number;
+    static [DEFAULT_VALUE]: number;
+    static [PURIFIED_VALUE]: number;
+    static [EXAMPLE_VALUE]: number;
     static validate(value: string | number): boolean;
     static parseValue(input: string | number): number;
     static serializeValue(value: number): number;
@@ -65,10 +65,11 @@ export declare class Float extends PrimitiveScalar {
 /** 24-character hexadecimal id primitive used by Akan document and signal models. */
 export declare class ID extends PrimitiveScalar {
     static refName: "ID";
-    static [PRIMITIVE_SERVER_VALUE]: string;
-    static [PRIMITIVE_CLIENT_VALUE]: string;
-    static [PRIMITIVE_DEFAULT_VALUE]: string;
-    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    static [SERVER_VALUE]: string;
+    static [CLIENT_VALUE]: string;
+    static [DEFAULT_VALUE]: string;
+    static [PURIFIED_VALUE]: string;
+    static [EXAMPLE_VALUE]: string;
     static validate(value: string): boolean;
     static parseValue(input: string): string;
     static serializeValue(value: string): string;
@@ -79,24 +80,26 @@ export declare class ID extends PrimitiveScalar {
 /** Open object primitive for intentionally flexible payloads or metadata blobs. */
 export declare class Any extends PrimitiveScalar {
     static refName: "Any";
-    static [PRIMITIVE_DEFAULT_VALUE]: object | null;
-    static [PRIMITIVE_EXAMPLE_VALUE]: object;
+    static [DEFAULT_VALUE]: object | null;
+    static [EXAMPLE_VALUE]: object;
 }
 export declare class Upload extends PrimitiveScalar {
     static refName: "Upload";
-    static [PRIMITIVE_SERVER_VALUE]: File;
-    static [PRIMITIVE_CLIENT_VALUE]: File;
-    static [PRIMITIVE_DEFAULT_VALUE]: File | null;
-    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    static [SERVER_VALUE]: File;
+    static [CLIENT_VALUE]: File;
+    static [DEFAULT_VALUE]: File | null;
+    static [PURIFIED_VALUE]: File;
+    static [EXAMPLE_VALUE]: string;
     __TEMP_TYPE__: "Upload";
 }
 declare global {
     interface StringConstructor {
         refName: "String";
-        [PRIMITIVE_SERVER_VALUE]: string;
-        [PRIMITIVE_CLIENT_VALUE]: string;
-        [PRIMITIVE_DEFAULT_VALUE]: string;
-        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        [SERVER_VALUE]: string;
+        [CLIENT_VALUE]: string;
+        [DEFAULT_VALUE]: string;
+        [PURIFIED_VALUE]: string;
+        [EXAMPLE_VALUE]: string;
         validate(value: string): boolean;
         parseValue(input: string): string;
         serializeValue(value: string): string;
@@ -106,10 +109,11 @@ declare global {
     }
     interface BooleanConstructor {
         refName: "Boolean";
-        [PRIMITIVE_SERVER_VALUE]: boolean;
-        [PRIMITIVE_CLIENT_VALUE]: boolean;
-        [PRIMITIVE_DEFAULT_VALUE]: boolean;
-        [PRIMITIVE_EXAMPLE_VALUE]: boolean;
+        [SERVER_VALUE]: boolean;
+        [CLIENT_VALUE]: boolean;
+        [DEFAULT_VALUE]: boolean;
+        [PURIFIED_VALUE]: boolean;
+        [EXAMPLE_VALUE]: boolean;
         validate(value: boolean | number): boolean;
         parseValue(input: boolean | number): boolean | number;
         serializeValue(value: boolean | number): boolean | number;
@@ -119,10 +123,11 @@ declare global {
     }
     interface DateConstructor {
         refName: "Date";
-        [PRIMITIVE_SERVER_VALUE]: Dayjs;
-        [PRIMITIVE_CLIENT_VALUE]: Dayjs;
-        [PRIMITIVE_DEFAULT_VALUE]: Dayjs;
-        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        [SERVER_VALUE]: Dayjs;
+        [CLIENT_VALUE]: Dayjs;
+        [DEFAULT_VALUE]: Dayjs;
+        [PURIFIED_VALUE]: Dayjs;
+        [EXAMPLE_VALUE]: string;
         validate(value: Date): boolean;
         parseValue(input: Date): Dayjs;
         serializeValue(value: Dayjs | Date): Date;

package/types/base/symbols.d.ts

@@ -9,3 +9,8 @@ export declare const STATE_META: unique symbol;
 export declare const STATE_INIT_META: unique symbol;
 export declare const STATE_DERIVED_META: unique symbol;
 export declare const ACTION_META: unique symbol;
+export declare const SERVER_VALUE: unique symbol;
+export declare const CLIENT_VALUE: unique symbol;
+export declare const DEFAULT_VALUE: unique symbol;
+export declare const EXAMPLE_VALUE: unique symbol;
+export declare const PURIFIED_VALUE: unique symbol;

package/types/base/types.d.ts

@@ -33,6 +33,7 @@ export type ObjectAssign<Objects extends object[], Acc = unknown> = Objects exte
     infer First extends object,
     ...infer Rest extends object[]
 ] ? ObjectAssign<Rest, Assign<Acc, First>> : Acc;
+export type ObjectAssignKeyOfObjects<T extends object[], Key extends PropertyKey, Acc = Record<never, never>> = T extends [infer First extends object, ...infer Rest extends object[]] ? Key extends keyof First ? First[Key] extends object ? ObjectAssignKeyOfObjects<Rest, Key, Assign<Acc, First[Key]>> : ObjectAssignKeyOfObjects<Rest, Key, Acc> : ObjectAssignKeyOfObjects<Rest, Key, Acc> : Acc;
 export type MergeAll<T extends object[], Acc = unknown> = T extends [
     infer First extends object,
     ...infer Rest extends object[]

package/types/constant/constantRegistry.d.ts

@@ -1,10 +1,6 @@
-import { type Cls, type EnumInstance, FIELD_META, type GetStateObject, type PrimitiveScalar } from "akanjs/base";
-import { type ConstantCls, type FieldObject, type PurifiedModel } from ".";
+import { type Cls, type EnumInstance, type GetStateObject, type PrimitiveScalar } from "akanjs/base";
+import { type ConstantCls, type ConstantModelRef, type FieldObject, type PurifiedModel } from ".";
 import type { ConstantType, DefaultOf, DocumentModel, QueryOf } from "./types.d.ts";
-type ConstantModelRef<FieldObj extends FieldObject = FieldObject> = Cls<unknown, {
-    [FIELD_META]: FieldObj;
-    modelType: ConstantType;
-}>;
 /** Runtime registry for Akan constant model metadata, refs, enums, and generated model contracts. */
 export declare class ConstantRegistry {
     static database: Map<string, ConstantModel<string, any, any, any, any, any, FieldObject, Capitalize<string>, GetStateObject<{
@@ -49,7 +45,7 @@ export declare class ConstantRegistry {
         allowEmpty?: AllowEmpty;
     }): AllowEmpty extends true ? ScalarConstantModel | undefined : ScalarConstantModel;
     static getModelRef(refName: string, modelType?: ConstantType): Cls | typeof PrimitiveScalar;
-    static buildModel<T extends string, InputRef extends ConstantModelRef, ObjectRef extends ConstantModelRef, FullFieldObj extends FieldObject, FullRef extends ConstantModelRef<FullFieldObj>, LightRef extends ConstantModelRef, InsightRef extends ConstantModelRef, Input = InstanceType<InputRef>, Obj = InstanceType<ObjectRef>, Full = InstanceType<FullRef>, Light = InstanceType<LightRef>, Insight = InstanceType<InsightRef>>(refName: T, inputRef: InputRef, objectRef: ObjectRef, fullRef: FullRef, lightRef: LightRef, insightRef: InsightRef, constExports: Record<string, unknown>): ConstantModel<T, Input, Obj, Full, Light, Insight, FullFieldObj, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DefaultOf<Insight>, PurifiedModel<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>, GetStateObject<Light>, GetStateObject<Insight>>;
+    static buildModel<T extends string, InputRef extends ConstantModelRef, ObjectRef extends ConstantModelRef, FullFieldObj extends FieldObject, FullRef extends ConstantModelRef<any, FullFieldObj>, LightRef extends ConstantModelRef, InsightRef extends ConstantModelRef, Input = InstanceType<InputRef>, Obj = InstanceType<ObjectRef>, Full = InstanceType<FullRef>, Light = InstanceType<LightRef>, Insight = InstanceType<InsightRef>>(refName: T, inputRef: InputRef, objectRef: ObjectRef, fullRef: FullRef, lightRef: LightRef, insightRef: InsightRef, constExports: Record<string, unknown>): ConstantModel<T, Input, Obj, Full, Light, Insight, FullFieldObj, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DefaultOf<Insight>, PurifiedModel<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>, GetStateObject<Light>, GetStateObject<Insight>>;
     static buildScalar<T extends string, Model>(refName: T, Model: Cls<Model>, constExports: Record<string, unknown>): ScalarConstantModel<T, Model, DefaultOf<Model>, DocumentModel<Model>, PurifiedModel<Model>>;
     static serialize<Value>(modelRef: Cls | Cls[], value: Value, nullable?: boolean): Value;
     static deserialize<Value>(modelRef: Cls | Cls[], value: Value, nullable?: boolean): Value;
@@ -86,4 +82,3 @@ export interface ScalarConstantModel<T extends string = string, Model = any, _De
     _Doc: _Doc;
     _PurifiedInput: _PurifiedInput;
 }
-export {};

package/types/constant/deserialize.d.ts

@@ -1,6 +1,6 @@
 import { type PrimitiveScalar } from "akanjs/base";
-import { type ConstantCls } from ".";
-export declare const deserialize: (argRef: ConstantCls | PrimitiveScalar, arrDepth: number, value: unknown, { key, nullable, convertFn }: {
+import { type ConstantModelRef } from ".";
+export declare const deserialize: (argRef: ConstantModelRef | PrimitiveScalar, arrDepth: number, value: unknown, { key, nullable, convertFn }: {
     key?: string;
     nullable?: boolean;
     convertFn?: (value: unknown) => unknown;

package/types/constant/fieldInfo.d.ts

@@ -1,19 +1,23 @@
-import { type Any, type Cls, type Dayjs, type EnumInstance, type Float, Int, PRIMITIVE_CLIENT_VALUE, PRIMITIVE_SERVER_VALUE, type PrimitiveScalar, type SingleValue, type UnCls } from "akanjs/base";
-import type { ConstantCls } from "./via.d.ts";
+import { type Any, CLIENT_VALUE, type Cls, type Dayjs, type EnumInstance, type Float, Int, type PrimitiveScalar, SERVER_VALUE, type SingleValue, type UnCls } from "akanjs/base";
+import type { BaseObject } from "./types.d.ts";
+import type { ConstantModelRef } from "./via.d.ts";
 export type ParamFieldType = (typeof PrimitiveScalar & {
-    [PRIMITIVE_CLIENT_VALUE]: string | number | boolean | Dayjs;
+    [CLIENT_VALUE]: string | number | boolean | Dayjs;
 }) | EnumInstance<string, any>;
 export type ConstantFieldType = typeof PrimitiveScalar | Cls | MapConstructor | EnumInstance<string, number>;
 export type ConstantFieldTypeInput = ConstantFieldType | ConstantFieldType[] | ConstantFieldType[][] | ConstantFieldType[][][];
-export type FieldToValue<Field, MapValue = any> = Field extends null ? FieldToValue<Exclude<Field, null>> | null : Field extends MapConstructor ? Map<string, FieldToValue<MapValue>> : Field extends (infer F)[] ? FieldToValue<F>[] : Field extends {
-    [PRIMITIVE_SERVER_VALUE]: infer V;
-} ? V : Field extends EnumInstance<string, infer V> ? V : Field extends Cls ? UnCls<Field> : never;
+export type FieldToValue<Field, MapValue = any> = Field extends null ? FieldToValue<Exclude<Field, null>> | null : Field extends MapConstructor ? Map<string, FieldToValue<MapValue>> : Field extends (infer F)[] ? FieldToValue<F>[] : Field extends typeof PrimitiveScalar | StringConstructor | BooleanConstructor | DateConstructor ? Field[typeof SERVER_VALUE] : Field extends ConstantModelRef ? UnCls<Field> : Field extends {
+    [SERVER_VALUE]: infer V;
+} ? V : Field extends Cls ? UnCls<Field> : never;
 export interface FieldInfoObject {
-    [key: string]: FieldInfo<any, ConstantFieldTypeInput | null, any>;
+    [key: string]: FieldInfo<any, ConstantFieldTypeInput | null, any, any, any, boolean, boolean, boolean, boolean, boolean, boolean, boolean>;
 }
 export type ExtractFieldInfoObject<Obj extends FieldInfoObject> = {
-    [K in keyof Obj]: Obj[K] extends FieldInfo<any, infer FieldValue, infer ExplicitType, infer MapValue> ? unknown extends ExplicitType ? FieldToValue<FieldValue, MapValue> : ExplicitType : never;
+    [K in keyof Obj]: unknown extends Obj[K]["explicitType"] ? FieldToValue<Obj[K]["value"], Obj[K]["mapValue"]> : Obj[K]["explicitType"];
 };
+type FieldKindSource<Value> = NonNullable<SingleValue<Value>>;
+type IsNullableValue<Value> = null extends Value ? true : false;
+type FieldInfoValue<Value, ExplicitType, MapValue> = unknown extends ExplicitType ? FieldToValue<Value, MapValue> : ExplicitType;
 export type ConstantFieldKind = "property" | "hidden" | "secret" | "resolve";
 export interface ConstantFieldProps<FieldType extends ConstantFieldKind = ConstantFieldKind, FieldValue = any, MapValue = any, Metadata = {
     [key: string]: any;
@@ -43,15 +47,23 @@ export interface ConstantFieldProps<FieldType extends ConstantFieldKind = Consta
 }
 export declare const fieldPresets: readonly ["email", "password", "url"];
 export type FieldPreset = (typeof fieldPresets)[number];
-declare class FieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never> {
+declare class FieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, KindSource = FieldKindSource<Value>, IsRelation extends boolean = UnCls<KindSource> extends BaseObject ? true : false, IsEnum extends boolean = KindSource extends EnumInstance<string, any> ? true : false, IsPrimitive extends boolean = KindSource extends typeof PrimitiveScalar ? true : false, IsMap extends boolean = KindSource extends MapConstructor ? true : false, IsScalar extends boolean = IsRelation extends true ? false : IsEnum extends true ? false : IsPrimitive extends true ? false : IsMap extends true ? false : true, IsHidden extends boolean = FieldType extends "hidden" ? true : false, IsSecret extends boolean = FieldType extends "secret" ? true : false> {
     readonly value: Value;
     readonly type: ConstantFieldTypeInput;
     readonly option: ConstantFieldProps;
     explicitType: ExplicitType;
+    mapValue: MapValue;
+    _isEnum: IsEnum;
+    _isPrimitive: IsPrimitive;
+    _isScalar: IsScalar;
+    _isRelation: IsRelation;
+    _isHidden: IsHidden;
+    _isSecret: IsSecret;
+    _isMap: IsMap;
     constructor(value: Value, option: ConstantFieldProps<FieldType, any, MapValue>);
     optional(): FieldInfo<FieldType, Value | null, ExplicitType | null, MapValue>;
     meta(meta: ConstantFieldProps["meta"]): this;
-    toField(): ConstantField<FieldType, Value, ExplicitType, MapValue, false, {
+    toField(): ConstantField<FieldType, Value, ExplicitType, MapValue, IsNullableValue<FieldInfoValue<Value, ExplicitType, MapValue>>, IsRelation, IsEnum, IsPrimitive, IsScalar, IsHidden, IsSecret, IsMap, {
         [key: string]: any;
     }>;
 }
@@ -77,7 +89,7 @@ interface ConstantFieldBuildProps<FieldType extends ConstantFieldKind = any, Fie
     of?: MapValue;
     validate?: (value: FieldValue, model: any) => boolean;
     text?: "search" | "filter";
-    modelRef: ConstantCls;
+    modelRef: ConstantModelRef;
     arrDepth: number;
     optArrDepth: number;
     meta: Metadata;
@@ -88,11 +100,13 @@ export interface FieldProps extends ConstantFieldBuildProps {
     isArray: boolean;
     isMap: boolean;
 }
+type ConstantFieldFromInfoParts<FieldType extends ConstantFieldKind, Value extends ConstantFieldTypeInput | null, ExplicitType, MapValue, IsRelation extends boolean, IsEnum extends boolean, IsPrimitive extends boolean, IsMap extends boolean, IsScalar extends boolean, IsHidden extends boolean, IsSecret extends boolean, _FieldValue = FieldInfoValue<Value, ExplicitType, MapValue>> = ConstantField<FieldType, Value, _FieldValue, MapValue, IsNullableValue<_FieldValue>, IsRelation, IsEnum, IsPrimitive, IsScalar, IsHidden, IsSecret, IsMap>;
+type ConstantFieldFromInfo<Info> = Info extends FieldInfo<infer FieldType, infer Value, infer ExplicitType, infer MapValue, infer _KindSource, infer IsRelation, infer IsEnum, infer IsPrimitive, infer IsMap, infer IsScalar, infer IsHidden, infer IsSecret> ? ConstantFieldFromInfoParts<FieldType, Value, ExplicitType, MapValue, IsRelation, IsEnum, IsPrimitive, IsMap, IsScalar, IsHidden, IsSecret> : never;
 export type FieldInfoObjectToFieldObject<Obj extends FieldInfoObject> = {
-    [K in keyof Obj]: Obj[K] extends FieldInfo<infer FieldType, infer Value, infer ExplicitType, infer MapValue> ? ConstantField<FieldType, Value, unknown extends ExplicitType ? FieldToValue<Value, MapValue> : ExplicitType, MapValue> : never;
+    [K in keyof Obj]: ConstantFieldFromInfo<Obj[K]>;
 };
 /** Runtime metadata for a single Akan constant field. */
-export declare class ConstantField<FieldType extends ConstantFieldKind = ConstantFieldKind, Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+export declare class ConstantField<FieldType extends ConstantFieldKind = ConstantFieldKind, Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = boolean, IsRelation extends boolean = boolean, IsEnum extends boolean = boolean, IsPrimitive extends boolean = boolean, IsScalar extends boolean = boolean, IsHidden extends boolean = boolean, IsSecret extends boolean = boolean, IsMap extends boolean = boolean, Metadata = {
     [key: string]: any;
 }> implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata> {
     static getBaseModelField(): FieldObject;
@@ -118,14 +132,21 @@ export declare class ConstantField<FieldType extends ConstantFieldKind = Constan
     readonly of?: MapValue;
     readonly validate?: (value: FieldValue, model: any) => boolean;
     readonly text?: "search" | "filter";
-    readonly modelRef: ConstantCls;
+    readonly modelRef: ConstantModelRef;
     readonly arrDepth: number;
     readonly optArrDepth: number;
     readonly meta: Metadata;
+    _isScalar: IsScalar;
+    _isRelation: IsRelation;
+    _isEnum: IsEnum;
+    _isPrimitive: IsPrimitive;
+    _isHidden: IsHidden;
+    _isSecret: IsSecret;
+    _isMap: IsMap;
     constructor(props: ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>);
-    static fromFieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+    static fromFieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, FieldValue = any, MapValue = any, Nullable extends boolean = IsNullableValue<FieldInfoValue<Value, FieldValue, MapValue>>, KindSource = FieldKindSource<Value>, IsRelation extends boolean = false, IsEnum extends boolean = false, IsPrimitive extends boolean = false, IsMap extends boolean = false, IsScalar extends boolean = false, IsHidden extends boolean = false, IsSecret extends boolean = false, Metadata = {
         [key: string]: any;
-    }>(fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue>): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, Metadata>;
+    }>(fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue, KindSource, IsRelation, IsEnum, IsPrimitive, IsMap, IsScalar, IsHidden, IsSecret>): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, IsRelation, IsEnum, IsPrimitive, IsScalar, IsHidden, IsSecret, IsMap, Metadata>;
     get isClass(): boolean;
     get isScalar(): boolean;
     get isArray(): boolean;
@@ -143,12 +164,12 @@ type FieldOption<Value extends ConstantFieldTypeInput, MapValue = Value extends
 export type PlainTypeToFieldType<PlainType> = PlainType extends [infer First, ...infer Rest] ? PlainTypeToFieldType<First>[] : PlainType extends number ? typeof Int | typeof Float : PlainType extends string ? StringConstructor : typeof Any;
 /** Builds a stored property field with optional validation, default, ref, text, and metadata options. */
 export declare const field: {
-    <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"property", Value, ExplicitType, MapValue>;
-    hidden<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue>;
-    secret<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"secret", Value | null, ExplicitType | null, MapValue>;
+    <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"property", Value, ExplicitType, MapValue, FieldKindSource<Value>, UnCls<FieldKindSource<Value>> extends BaseObject ? true : false, FieldKindSource<Value> extends infer T ? T extends FieldKindSource<Value> ? T extends EnumInstance<string, any> ? true : false : never : never, FieldKindSource<Value> extends infer T_1 ? T_1 extends FieldKindSource<Value> ? T_1 extends typeof PrimitiveScalar ? true : false : never : never, FieldKindSource<Value> extends infer T_2 ? T_2 extends FieldKindSource<Value> ? T_2 extends MapConstructor ? true : false : never : never, (UnCls<FieldKindSource<Value>> extends BaseObject ? true : false) extends infer T_3 ? T_3 extends (UnCls<FieldKindSource<Value>> extends BaseObject ? true : false) ? T_3 extends true ? false : (FieldKindSource<Value> extends infer T_4 ? T_4 extends FieldKindSource<Value> ? T_4 extends EnumInstance<string, any> ? true : false : never : never) extends infer T_5 ? T_5 extends (FieldKindSource<Value> extends infer T_12 ? T_12 extends FieldKindSource<Value> ? T_12 extends EnumInstance<string, any> ? true : false : never : never) ? T_5 extends true ? false : (FieldKindSource<Value> extends infer T_6 ? T_6 extends FieldKindSource<Value> ? T_6 extends typeof PrimitiveScalar ? true : false : never : never) extends infer T_7 ? T_7 extends (FieldKindSource<Value> extends infer T_11 ? T_11 extends FieldKindSource<Value> ? T_11 extends typeof PrimitiveScalar ? true : false : never : never) ? T_7 extends true ? false : (FieldKindSource<Value> extends infer T_8 ? T_8 extends FieldKindSource<Value> ? T_8 extends MapConstructor ? true : false : never : never) extends infer T_9 ? T_9 extends (FieldKindSource<Value> extends infer T_10 ? T_10 extends FieldKindSource<Value> ? T_10 extends MapConstructor ? true : false : never : never) ? T_9 extends true ? false : true : never : never : never : never : never : never : never : never, false, false>;
+    hidden<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue, SingleValue<Value> & {}, UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false, SingleValue<Value> & {} extends infer T ? T extends SingleValue<Value> & {} ? T extends EnumInstance<string, any> ? true : false : never : never, SingleValue<Value> & {} extends infer T_1 ? T_1 extends SingleValue<Value> & {} ? T_1 extends typeof PrimitiveScalar ? true : false : never : never, SingleValue<Value> & {} extends infer T_2 ? T_2 extends SingleValue<Value> & {} ? T_2 extends MapConstructor ? true : false : never : never, (UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false) extends infer T_3 ? T_3 extends (UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false) ? T_3 extends true ? false : (SingleValue<Value> & {} extends infer T_4 ? T_4 extends SingleValue<Value> & {} ? T_4 extends EnumInstance<string, any> ? true : false : never : never) extends infer T_5 ? T_5 extends (SingleValue<Value> & {} extends infer T_12 ? T_12 extends SingleValue<Value> & {} ? T_12 extends EnumInstance<string, any> ? true : false : never : never) ? T_5 extends true ? false : (SingleValue<Value> & {} extends infer T_6 ? T_6 extends SingleValue<Value> & {} ? T_6 extends typeof PrimitiveScalar ? true : false : never : never) extends infer T_7 ? T_7 extends (SingleValue<Value> & {} extends infer T_11 ? T_11 extends SingleValue<Value> & {} ? T_11 extends typeof PrimitiveScalar ? true : false : never : never) ? T_7 extends true ? false : (SingleValue<Value> & {} extends infer T_8 ? T_8 extends SingleValue<Value> & {} ? T_8 extends MapConstructor ? true : false : never : never) extends infer T_9 ? T_9 extends (SingleValue<Value> & {} extends infer T_10 ? T_10 extends SingleValue<Value> & {} ? T_10 extends MapConstructor ? true : false : never : never) ? T_9 extends true ? false : true : never : never : never : never : never : never : never : never, true, false>;
+    secret<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"secret", Value | null, ExplicitType | null, MapValue, SingleValue<Value> & {}, UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false, SingleValue<Value> & {} extends infer T ? T extends SingleValue<Value> & {} ? T extends EnumInstance<string, any> ? true : false : never : never, SingleValue<Value> & {} extends infer T_1 ? T_1 extends SingleValue<Value> & {} ? T_1 extends typeof PrimitiveScalar ? true : false : never : never, SingleValue<Value> & {} extends infer T_2 ? T_2 extends SingleValue<Value> & {} ? T_2 extends MapConstructor ? true : false : never : never, (UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false) extends infer T_3 ? T_3 extends (UnCls<SingleValue<Value> & {}> extends BaseObject ? true : false) ? T_3 extends true ? false : (SingleValue<Value> & {} extends infer T_4 ? T_4 extends SingleValue<Value> & {} ? T_4 extends EnumInstance<string, any> ? true : false : never : never) extends infer T_5 ? T_5 extends (SingleValue<Value> & {} extends infer T_12 ? T_12 extends SingleValue<Value> & {} ? T_12 extends EnumInstance<string, any> ? true : false : never : never) ? T_5 extends true ? false : (SingleValue<Value> & {} extends infer T_6 ? T_6 extends SingleValue<Value> & {} ? T_6 extends typeof PrimitiveScalar ? true : false : never : never) extends infer T_7 ? T_7 extends (SingleValue<Value> & {} extends infer T_11 ? T_11 extends SingleValue<Value> & {} ? T_11 extends typeof PrimitiveScalar ? true : false : never : never) ? T_7 extends true ? false : (SingleValue<Value> & {} extends infer T_8 ? T_8 extends SingleValue<Value> & {} ? T_8 extends MapConstructor ? true : false : never : never) extends infer T_9 ? T_9 extends (SingleValue<Value> & {} extends infer T_10 ? T_10 extends SingleValue<Value> & {} ? T_10 extends MapConstructor ? true : false : never : never) ? T_9 extends true ? false : true : never : never : never : never : never : never : never : never, false, true>;
 };
 /** Builds a resolved field that is derived rather than treated as a stored property. */
-export declare const resolve: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>) => FieldInfo<"resolve", Value, ExplicitType, MapValue>;
+export declare const resolve: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>) => FieldInfo<"resolve", Value, ExplicitType, MapValue, FieldKindSource<Value>, UnCls<FieldKindSource<Value>> extends BaseObject ? true : false, FieldKindSource<Value> extends infer T ? T extends FieldKindSource<Value> ? T extends EnumInstance<string, any> ? true : false : never : never, FieldKindSource<Value> extends infer T_1 ? T_1 extends FieldKindSource<Value> ? T_1 extends typeof PrimitiveScalar ? true : false : never : never, FieldKindSource<Value> extends infer T_2 ? T_2 extends FieldKindSource<Value> ? T_2 extends MapConstructor ? true : false : never : never, (UnCls<FieldKindSource<Value>> extends BaseObject ? true : false) extends infer T_3 ? T_3 extends (UnCls<FieldKindSource<Value>> extends BaseObject ? true : false) ? T_3 extends true ? false : (FieldKindSource<Value> extends infer T_4 ? T_4 extends FieldKindSource<Value> ? T_4 extends EnumInstance<string, any> ? true : false : never : never) extends infer T_5 ? T_5 extends (FieldKindSource<Value> extends infer T_12 ? T_12 extends FieldKindSource<Value> ? T_12 extends EnumInstance<string, any> ? true : false : never : never) ? T_5 extends true ? false : (FieldKindSource<Value> extends infer T_6 ? T_6 extends FieldKindSource<Value> ? T_6 extends typeof PrimitiveScalar ? true : false : never : never) extends infer T_7 ? T_7 extends (FieldKindSource<Value> extends infer T_11 ? T_11 extends FieldKindSource<Value> ? T_11 extends typeof PrimitiveScalar ? true : false : never : never) ? T_7 extends true ? false : (FieldKindSource<Value> extends infer T_8 ? T_8 extends FieldKindSource<Value> ? T_8 extends MapConstructor ? true : false : never : never) extends infer T_9 ? T_9 extends (FieldKindSource<Value> extends infer T_10 ? T_10 extends FieldKindSource<Value> ? T_10 extends MapConstructor ? true : false : never : never) ? T_9 extends true ? false : true : never : never : never : never : never : never : never : never, false, false>;
 export type FieldBuilder = typeof field;
 export type FieldResolver = typeof resolve;
 export {};

package/types/constant/immerify.d.ts

@@ -1,2 +1,2 @@
-import type { ConstantCls } from ".";
-export declare const immerify: <T extends object>(modelRef: ConstantCls, objOrArr: T) => T;
+import type { ConstantModelRef } from ".";
+export declare const immerify: <T extends object>(modelRef: ConstantModelRef, objOrArr: T) => T;

package/types/constant/purify.d.ts

@@ -1,5 +1,5 @@
 import { type Dayjs, type GetStateObject, type Upload } from "akanjs/base";
-import { type BaseObject, type ConstantCls, type DefaultOf } from ".";
+import { type BaseObject, type ConstantModelRef, type DefaultOf, type DefaultOfSchema } from ".";
 type Purified<O> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? Dayjs : O extends object ? PurifiedModel<O> : O;
 type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
     [K in StateKeys as null extends T[K] ? never : K]: Purified<T[K]>;
@@ -8,5 +8,6 @@ type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof
 };
 export type PurifiedModel<T> = T extends Upload[] ? FileList : T extends (infer S)[] ? PurifiedModel<S>[] : T extends string | number | boolean | Dayjs | File ? T : T extends Map<infer K, infer V> ? Map<K, PurifiedModel<V>> : PurifiedWithObjectToId<T>;
 export type PurifyFunc<Input, _DefaultInput = DefaultOf<Input>, _PurifiedInput = PurifiedModel<Input>> = (self: _DefaultInput, isChild?: boolean) => _PurifiedInput | null;
-export declare const makePurify: <I>(modelRef: ConstantCls<I>) => PurifyFunc<I>;
+export type PurifyFuncV2<Input, RelationKey extends string = never, _DefaultInput = DefaultOfSchema<Input, RelationKey>, _PurifiedInput = PurifiedModel<Input>> = (self: _DefaultInput, isChild?: boolean) => _PurifiedInput | null;
+export declare const makePurify: <I>(modelRef: ConstantModelRef<I>) => PurifyFunc<I>;
 export {};

package/types/constant/serialize.d.ts

@@ -1,11 +1,11 @@
 import { type Dayjs, type PrimitiveScalar } from "akanjs/base";
-import type { ConstantCls } from ".";
+import type { ConstantModelRef } from ".";
 export type Serialized<O> = O extends (infer V)[] ? Serialized<V>[] : O extends Dayjs ? Date : O extends Map<infer K, infer V> ? {
     [key in K & string]: Serialized<V>;
 } : O extends object ? {
     [K in keyof O]: Serialized<O[K]>;
 } : O;
-export declare const serialize: (argRef: ConstantCls | PrimitiveScalar, arrDepth: number, value: unknown, serializeType: "input" | "object" | undefined, { nullable, key }: {
+export declare const serialize: (argRef: ConstantModelRef | PrimitiveScalar, arrDepth: number, value: unknown, serializeType: "input" | "object" | undefined, { nullable, key }: {
     nullable?: boolean;
     key?: string;
 }) => object[] | null;

package/types/constant/types.d.ts

@@ -14,6 +14,9 @@ export type FieldState<T> = T extends {
 export type DefaultOf<S> = GetStateObject<{
     [K in keyof S]: FieldState<S[K]>;
 }>;
+export type DefaultOfSchema<Schema, RelationKey = never> = [RelationKey] extends [never] ? Schema : {
+    [K in keyof Schema]: Schema[K] | (K extends RelationKey ? null : never);
+};
 export type GetPlainObject<T, O extends string> = Omit<{
     [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K extends "set" | "save" | "refresh" ? never : K]: T[K];
 }, O>;
@@ -67,7 +70,9 @@ export declare const DEFAULT_PAGE_SIZE = 20;
 export interface TextDoc {
     [key: string]: string | TextDoc;
 }
-export type NonFunctionalKeys<T> = keyof T extends (...args: never[]) => unknown ? never : keyof T;
+export type NonFunctionalKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: never[]) => unknown ? never : K;
+}[keyof T];
 export declare const unsetDate: Dayjs;
 export declare const MAX_INT = 2147483647;
 declare const Responsive_base: import("akanjs/base").EnumInstance<"responsive", "xl" | "lg" | "md" | "sm" | "xs">;

package/types/constant/via.d.ts

@@ -1,19 +1,70 @@
-import { type Cls, type EnumInstance, FIELD_META, type MergeAllKeyOfObjects, type MergeAllTypes } from "akanjs/base";
-import { ConstantField, type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, type FieldInfoObjectToFieldObject, type FieldObject, type FieldResolver } from "./fieldInfo.d.ts";
-import { type PurifyFunc } from "./purify.d.ts";
-import type { BaseInsight, BaseObject, ConstantType, DefaultOf, NonFunctionalKeys } from "./types.d.ts";
+import { CLIENT_VALUE, type Cls, DEFAULT_VALUE, type EnumInstance, FIELD_META, type ObjectAssign, type ObjectAssignKeyOfObjects, PURIFIED_VALUE, SERVER_VALUE } from "akanjs/base";
+import { type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, type FieldInfoObjectToFieldObject, type FieldObject, type FieldResolver } from "./fieldInfo.d.ts";
+import { type PurifiedModel, type PurifyFunc } from "./purify.d.ts";
+import type { BaseInsight, BaseObject, ConstantType, DefaultOf, DefaultOfSchema, NonFunctionalKeys } from "./types.d.ts";
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
 type OmitBase<T> = Omit<T, BaseFields>;
+type MergeOwnSchemas<Models extends object[]> = ObjectAssignKeyOfObjects<Models, "_OwnSchema">;
+type MergeOwnFieldObjects<Models extends object[]> = ObjectAssignKeyOfObjects<Models, "_OwnFieldObj">;
+type MergeWithOwnSchemas<Models extends object[], OwnSchema extends object> = ObjectAssign<[
+    MergeOwnSchemas<Models>,
+    OwnSchema
+]>;
+type MergeWithOwnFieldObjects<Models extends object[], OwnFieldObj extends object> = ObjectAssign<[
+    MergeOwnFieldObjects<Models>,
+    OwnFieldObj
+]>;
+type BuiltSchema<BuildField extends (builder: FieldBuilder) => FieldInfoObject> = ExtractFieldInfoObject<ReturnType<BuildField>>;
+type BuiltFieldObject<BuildField extends (builder: FieldBuilder) => FieldInfoObject> = FieldInfoObjectToFieldObject<ReturnType<BuildField>>;
+type ResolvedSchema<ResolveField extends (resolve: FieldResolver) => FieldInfoObject> = ExtractFieldInfoObject<ReturnType<ResolveField>>;
+type ResolvedFieldObject<ResolveField extends (resolve: FieldResolver) => FieldInfoObject> = FieldInfoObjectToFieldObject<ReturnType<ResolveField>>;
+type ConstantSetReturn<Self, Schema> = Self extends Schema & ConstantMethods<Schema> & infer Model ? unknown extends Model ? Self : Model : Self;
 export interface ConstantMethods<Schema = any> {
-    set: (obj: Partial<Schema>) => this;
+    set<Self extends Schema & ConstantMethods<Schema>>(this: Self, obj: Partial<Schema>): ConstantSetReturn<Self, Schema>;
 }
-export interface ConstantStatics<Schema = any, FieldObj extends FieldObject = FieldObject> {
+type DatabaseSchemaOf<Schema, HiddenKey> = {
+    [K in keyof Schema]: K extends HiddenKey ? NonNullable<Schema[K]> : Schema[K];
+};
+export interface ConstantStatics<Schema = any, OwnSchema = Schema, OwnFieldObj extends FieldObject = FieldObject, OptionalKey = never, RelationKey = never, PrimitiveKey = never, ScalarKey = never, EnumKey = never, MapKey = never, HiddenKey = never, SecretKey = never, ModelType extends ConstantType = ConstantType> {
+    [FIELD_META]: FieldObject;
+    getDefault: () => DefaultOfSchema<Schema, RelationKey>;
+    purify: PurifyFunc<Schema>;
+    modelType: ConstantType;
+    children: Set<ConstantModelRef>;
+    relations: Set<ConstantModelRef>;
+    enums: Set<EnumInstance>;
+    text: {
+        search: Set<string>;
+        filter: Set<string>;
+        children: {
+            search: Set<string>;
+            filter: Set<string>;
+        };
+    };
+    _OptionalKey: OptionalKey;
+    _RelationKey: RelationKey;
+    _PrimitiveKey: PrimitiveKey;
+    _ScalarKey: ScalarKey;
+    _EnumKey: EnumKey;
+    _MapKey: MapKey;
+    _HiddenKey: HiddenKey;
+    _SecretKey: SecretKey;
+    _OwnSchema: OwnSchema;
+    _OwnFieldObj: OwnFieldObj;
+    _DatabaseSchema: DatabaseSchemaOf<Schema, HiddenKey>;
+    _ModelType: ModelType;
+    [SERVER_VALUE]: Schema;
+    [CLIENT_VALUE]: Schema;
+    [DEFAULT_VALUE]: DefaultOfSchema<Schema, RelationKey>;
+    [PURIFIED_VALUE]: PurifiedModel<Schema>;
+}
+export interface DatabaseConstantStatics<Schema = any, FieldObj extends FieldObject = FieldObject> {
     [FIELD_META]: FieldObj;
     getDefault: () => DefaultOf<Schema>;
     purify: PurifyFunc<Schema>;
     modelType: ConstantType;
-    children: Set<ConstantCls>;
-    relations: Set<ConstantCls>;
+    children: Set<ConstantModelRef>;
+    relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
     text: {
         search: Set<string>;
@@ -24,32 +75,102 @@ export interface ConstantStatics<Schema = any, FieldObj extends FieldObject = Fi
         };
     };
     _DatabaseSchema: {
-        [K in keyof Schema]: K extends keyof FieldObj ? FieldObj[K] extends ConstantField<infer FieldType, any, any, any, any, any> ? FieldType extends "hidden" ? NonNullable<Schema[K]> : Schema[K] : Schema[K] : Schema[K];
+        [K in keyof Schema]: K extends keyof FieldObj ? FieldObj[K]["fieldType"] extends "hidden" ? NonNullable<Schema[K]> : Schema[K] : Schema[K];
     };
 }
-export type ConstantCls<Schema = any, FieldObj extends FieldObject = FieldObject> = (new (obj?: Partial<Schema>) => Schema & ConstantMethods<Schema>) & ConstantStatics<Schema, FieldObj>;
+export type ConstantModelRef<Schema = any, FieldObj extends FieldObject = FieldObject, ModelType extends ConstantType = ConstantType> = Cls<Schema, {
+    [FIELD_META]: FieldObj;
+    modelType: ModelType;
+    children: Set<ConstantModelRef>;
+    relations: Set<ConstantModelRef>;
+    enums: Set<EnumInstance>;
+    text: {
+        search: Set<string>;
+        filter: Set<string>;
+        children: {
+            search: Set<string>;
+            filter: Set<string>;
+        };
+    };
+}>;
+export type DocumentConstantModelRef<Schema = any, FieldObj extends FieldObject = FieldObject, ModelType extends ConstantType = ConstantType, DatabaseSchema = DatabaseSchemaOf<Schema, never>> = Cls<Schema, {
+    [FIELD_META]: FieldObj;
+    modelType: ModelType;
+    _DatabaseSchema: DatabaseSchema;
+    _ModelType: ModelType;
+}>;
+type FieldFlag = "nullable" | "_isRelation" | "_isPrimitive" | "_isScalar" | "_isEnum" | "_isHidden" | "_isSecret" | "_isMap";
+type TrueFieldFlag<Flag extends FieldFlag> = {
+    readonly [K in Flag]: true;
+};
+type KeysByFlag<FieldObj extends FieldObject, Flag extends FieldFlag> = {
+    [K in keyof FieldObj]: FieldObj[K] extends TrueFieldFlag<Flag> ? K : never;
+}[keyof FieldObj];
+type OptionalKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "nullable">;
+type RelationKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isRelation">;
+type PrimitiveKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isPrimitive">;
+type ScalarKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isScalar">;
+type EnumKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isEnum">;
+type HiddenKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isHidden">;
+type SecretKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isSecret">;
+type MapKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isMap">;
+type ConstantKeyChannelMap = {
+    optional: unknown;
+    relation: unknown;
+    primitive: unknown;
+    scalar: unknown;
+    enum: unknown;
+    map: unknown;
+    hidden: unknown;
+    secret: unknown;
+};
+type IsBroadFieldObject<FieldObj extends FieldObject> = string extends keyof FieldObj ? true : false;
+type ConstantKeyChannels<FieldObj extends FieldObject> = IsBroadFieldObject<FieldObj> extends true ? {
+    optional: never;
+    relation: never;
+    primitive: never;
+    scalar: never;
+    enum: never;
+    map: never;
+    hidden: never;
+    secret: never;
+} : {
+    optional: OptionalKeys<FieldObj>;
+    relation: RelationKeys<FieldObj>;
+    primitive: PrimitiveKeys<FieldObj>;
+    scalar: ScalarKeys<FieldObj>;
+    enum: EnumKeys<FieldObj>;
+    map: MapKeys<FieldObj>;
+    hidden: HiddenKeys<FieldObj>;
+    secret: SecretKeys<FieldObj>;
+};
+export type ConstantCls<Schema = any, FieldObj extends FieldObject = FieldObject, OwnSchema = Schema, OwnFieldObj extends FieldObject = FieldObj, ModelType extends ConstantType = ConstantType, _Channels extends ConstantKeyChannelMap = ConstantKeyChannels<FieldObj>> = (new (obj?: Partial<Schema>) => Schema & ConstantMethods<Schema>) & ConstantStatics<Schema, OwnSchema, OwnFieldObj, _Channels["optional"], _Channels["relation"], _Channels["primitive"], _Channels["scalar"], _Channels["enum"], _Channels["map"], _Channels["hidden"], _Channels["secret"], ModelType>;
 declare global {
-    interface DateConstructor extends ConstantStatics<unknown> {
+    interface DateConstructor extends DatabaseConstantStatics<unknown> {
     }
-    interface StringConstructor extends ConstantStatics<unknown> {
+    interface StringConstructor extends DatabaseConstantStatics<unknown> {
     }
-    interface BooleanConstructor extends ConstantStatics<unknown> {
+    interface BooleanConstructor extends DatabaseConstantStatics<unknown> {
     }
-    interface MapConstructor extends ConstantStatics<unknown> {
+    interface MapConstructor extends DatabaseConstantStatics<unknown> {
     }
 }
 /** Builds Akan constant models such as scalar, input, object, light, full, and insight classes. */
-export declare function via<Obj extends BaseObject, ObjFieldObj extends FieldObject, K extends NonFunctionalKeys<OmitBase<Obj>>, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, LightModels extends Cls[], _Schema = MergeAllTypes<LightModels> & Pick<Obj, K> & BaseObject & ExtractFieldInfoObject<ReturnType<ResolveField>>, _FieldObj extends FieldObject = MergeAllKeyOfObjects<LightModels, typeof FIELD_META> & Pick<ObjFieldObj, K & keyof ObjFieldObj> & FieldInfoObjectToFieldObject<ReturnType<ResolveField>>>(modelRef: Cls<Obj, {
+export declare function via<Obj extends BaseObject, ObjFieldObj extends FieldObject, K extends NonFunctionalKeys<OmitBase<Obj>>, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, LightModels extends Cls[], _DirectSchema extends object = ObjectAssign<[Pick<Obj, K> & BaseObject, ResolvedSchema<ResolveField>]>, _Schema extends object = MergeWithOwnSchemas<LightModels, _DirectSchema>, _DirectFieldObj extends FieldObject = ObjectAssign<[
+    Pick<ObjFieldObj, K & keyof ObjFieldObj>,
+    ResolvedFieldObject<ResolveField>
+]>, _FieldObj extends FieldObject = MergeWithOwnFieldObjects<LightModels, _DirectFieldObj> & FieldObject>(modelRef: Cls<Obj, {
     [FIELD_META]: ObjFieldObj;
-}>, fields: readonly K[], resolveField: ResolveField, ...lightModelRefs: LightModels): ConstantCls<_Schema, _FieldObj>;
-export declare function via<BuildField extends (builder: FieldBuilder) => FieldInfoObject, Inputs extends Cls[], _Schema = MergeAllTypes<Inputs> & ExtractFieldInfoObject<ReturnType<BuildField>>, _FieldObj extends FieldObject = MergeAllKeyOfObjects<Inputs, typeof FIELD_META> & FieldInfoObjectToFieldObject<ReturnType<BuildField>>>(buildField: BuildField, ...extendInputRefs: Inputs): ConstantCls<_Schema, _FieldObj>;
-export declare function via<Full extends BaseObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, Insights extends Cls[], _Schema = MergeAllTypes<Insights> & BaseInsight & ExtractFieldInfoObject<ReturnType<BuildField>>, _FieldObj extends FieldObject = MergeAllKeyOfObjects<Insights, typeof FIELD_META> & FieldInfoObjectToFieldObject<ReturnType<BuildField>>>(modelRef: Cls<Full>, buildField: BuildField, ...extendInsightRefs: Insights): ConstantCls<_Schema, _FieldObj>;
-export declare function via<Input, InputFieldObj extends FieldObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, ObjectModels extends Cls[], _Schema = MergeAllTypes<ObjectModels> & Input & BaseObject & ExtractFieldInfoObject<ReturnType<BuildField>>, _FieldObj extends FieldObject = MergeAllKeyOfObjects<ObjectModels, typeof FIELD_META> & InputFieldObj & FieldInfoObjectToFieldObject<ReturnType<BuildField>>>(inputRef: Cls<Input, {
+}>, fields: readonly K[], resolveField: ResolveField, ...lightModelRefs: LightModels): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "light">;
+export declare function via<BuildField extends (builder: FieldBuilder) => FieldInfoObject, _DirectSchema extends object = BuiltSchema<BuildField>, _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>>(buildField: BuildField): ConstantCls<_DirectSchema, _DirectFieldObj, _DirectSchema, _DirectFieldObj, "input" | "scalar">;
+export declare function via<BuildField extends (builder: FieldBuilder) => FieldInfoObject, FirstInput extends Cls, Inputs extends Cls[], _DirectSchema extends object = BuiltSchema<BuildField>, _InputRefs extends Cls[] = [FirstInput, ...Inputs], _Schema extends object = MergeWithOwnSchemas<_InputRefs, _DirectSchema>, _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>, _FieldObj extends FieldObject = MergeWithOwnFieldObjects<_InputRefs, _DirectFieldObj> & FieldObject>(buildField: BuildField, firstExtendInputRef: FirstInput, ...extendInputRefs: Inputs): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "input">;
+export declare function via<Full extends BaseObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, Insights extends Cls[], _DirectSchema extends object = ObjectAssign<[BaseInsight, BuiltSchema<BuildField>]>, _Schema extends object = MergeWithOwnSchemas<Insights, _DirectSchema>, _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>, _FieldObj extends FieldObject = MergeWithOwnFieldObjects<Insights, _DirectFieldObj> & FieldObject>(modelRef: Cls<Full>, buildField: BuildField, ...extendInsightRefs: Insights): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "insight">;
+export declare function via<Input, InputFieldObj extends FieldObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, ObjectModels extends Cls[], _DirectSchema extends object = ObjectAssign<[Input & object, BaseObject, BuiltSchema<BuildField>]>, _Schema extends object = MergeWithOwnSchemas<ObjectModels, _DirectSchema>, _DirectFieldObj extends FieldObject = ObjectAssign<[InputFieldObj, BuiltFieldObject<BuildField>]>, _FieldObj extends FieldObject = MergeWithOwnFieldObjects<ObjectModels, _DirectFieldObj> & FieldObject>(inputRef: Cls<Input, {
     [FIELD_META]: InputFieldObj;
-}>, buildField: BuildField, ...extendObjectRefs: ObjectModels): ConstantCls<_Schema, _FieldObj>;
-export declare function via<Obj, ObjFieldObj extends FieldObject, Light, LightFieldObj extends FieldObject, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, FullModels extends Cls[], _Schema = MergeAllTypes<FullModels> & Obj & Light & ExtractFieldInfoObject<ReturnType<ResolveField>>, _FieldObj extends FieldObject = MergeAllKeyOfObjects<FullModels, typeof FIELD_META> & ObjFieldObj & LightFieldObj & FieldInfoObjectToFieldObject<ReturnType<ResolveField>>>(objectRef: Cls<Obj, {
+}>, buildField: BuildField, ...extendObjectRefs: ObjectModels): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "object">;
+export declare function via<Obj, ObjFieldObj extends FieldObject, Light, LightFieldObj extends FieldObject, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, FullModels extends Cls[], _DirectSchema extends object = ObjectAssign<[Obj & object, Light & object, ResolvedSchema<ResolveField>]>, _Schema extends object = MergeWithOwnSchemas<FullModels, _DirectSchema>, _DirectFieldObj extends FieldObject = ObjectAssign<[ObjFieldObj, LightFieldObj, ResolvedFieldObject<ResolveField>]>, _FieldObj extends FieldObject = MergeWithOwnFieldObjects<FullModels, _DirectFieldObj> & FieldObject>(objectRef: Cls<Obj, {
     [FIELD_META]: ObjFieldObj;
 }>, lightModelRef: Cls<Light, {
     [FIELD_META]: LightFieldObj;
-}>, resolveField: ResolveField, ...fullModelRefs: FullModels): ConstantCls<_Schema, _FieldObj>;
+}>, resolveField: ResolveField, ...fullModelRefs: FullModels): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "full">;
 export {};