akanjs 2.2.4 → 2.2.6

package/types/constant/constantRegistry.d.ts

@@ -0,0 +1,89 @@
+import { type Cls, type EnumInstance, FIELD_META, type GetStateObject, type PrimitiveScalar } from "akanjs/base";
+import { type ConstantCls, 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<{
+        [x: string]: any;
+    }>, GetStateObject<{
+        [x: string]: any;
+    }>, GetStateObject<any>, GetStateObject<any>, GetStateObject<{
+        [x: string]: any;
+    }>, any, any, any, any, GetStateObject<any>, GetStateObject<any>>>;
+    static scalar: Map<string, ScalarConstantModel<string, any, GetStateObject<{
+        [x: string]: any;
+    }>, any, any>>;
+    static enum: Map<string, EnumInstance>;
+    static value: Map<string, unknown>;
+    static modelRefNameMap: Map<new (...args: never[]) => unknown, string>;
+    static has(modelRef: Cls): boolean;
+    static getRefName<AllowEmpty extends boolean = false>(modelRef: Cls, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? string | undefined : string;
+    static getModelName(modelRef: Cls): string;
+    static isObject(modelRef: Cls<unknown, {
+        modelType?: ConstantType;
+    }>): boolean;
+    static isFull(modelRef: Cls<unknown, {
+        modelType?: ConstantType;
+    }>): boolean;
+    static isLight(modelRef: Cls<unknown, {
+        modelType?: ConstantType;
+    }>): boolean;
+    static isInsight(modelRef: Cls<unknown, {
+        modelType?: ConstantType;
+    }>): boolean;
+    static isScalar(modelRef: Cls<unknown, {
+        modelType?: ConstantType;
+    }>): boolean;
+    static setDatabase(refName: string, cnst: ConstantModel): void;
+    static getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? ConstantModel | undefined : ConstantModel;
+    static setScalar(refName: string, cnst: ScalarConstantModel): void;
+    static getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        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 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;
+}
+export interface ConstantModel<T extends string = string, Input = any, Obj = any, Full = any, Light = any, Insight = any, FullFieldObj extends FieldObject = FieldObject, _CapitalizedRefName extends string = Capitalize<T>, _Default = DefaultOf<Full>, _DefaultInput = DefaultOf<Input>, _DefaultState = GetStateObject<Full>, _DefaultStateInput = GetStateObject<Input>, _DefaultInsight = DefaultOf<Insight>, _PurifiedInput = PurifiedModel<Input>, _Doc = DocumentModel<Full>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<_Doc>, _StateLight = GetStateObject<Light>, _StateInsight = GetStateObject<Insight>> {
+    refName: T;
+    input: ConstantCls<Input>;
+    object: ConstantCls<Obj>;
+    full: ConstantCls<Full, FullFieldObj>;
+    light: ConstantCls<Light>;
+    insight: ConstantCls<Insight>;
+    _CapitalizedRefName: _CapitalizedRefName;
+    _Input: Input;
+    _Obj: Obj;
+    _Full: Full;
+    _Light: Light;
+    _Insight: Insight;
+    _Default: _Default;
+    _DefaultInput: _DefaultInput;
+    _DefaultState: _DefaultState;
+    _DefaultStateInput: _DefaultStateInput;
+    _DefaultInsight: _DefaultInsight;
+    _PurifiedInput: _PurifiedInput;
+    _Doc: _Doc;
+    _DocInput: _DocInput;
+    _QueryOfDoc: _QueryOfDoc;
+    _StateLight: _StateLight;
+    _StateInsight: _StateInsight;
+}
+export interface ScalarConstantModel<T extends string = string, Model = any, _Default = DefaultOf<Model>, _Doc = DocumentModel<Model>, _PurifiedInput = PurifiedModel<Model>> {
+    refName: T;
+    model: ConstantCls<Model>;
+    _Default: _Default;
+    _Doc: _Doc;
+    _PurifiedInput: _PurifiedInput;
+}
+export {};

package/types/constant/crystalize.d.ts

@@ -0,0 +1,4 @@
+import { type GetStateObject } from "akanjs/base";
+import type { FieldProps } from ".";
+export type CrystalizeFunc<Model> = (self: GetStateObject<Model>, isChild?: boolean) => Model;
+export declare const crystalize: (field: FieldProps, value: unknown) => unknown;

package/types/constant/deserialize.d.ts

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

package/types/constant/fieldInfo.d.ts

@@ -0,0 +1,153 @@
+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";
+export type ParamFieldType = (typeof PrimitiveScalar & {
+    [PRIMITIVE_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 interface FieldInfoObject {
+    [key: string]: FieldInfo<any, ConstantFieldTypeInput | null, any>;
+}
+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;
+};
+export interface ConstantFieldProps<FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve", FieldValue = any, MapValue = any, Metadata = {
+    [key: string]: any;
+}> {
+    nullable?: boolean;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    default?: FieldValue | ((doc: {
+        id: string;
+    }) => FieldValue);
+    type?: FieldPreset;
+    fieldType?: FieldType;
+    immutable?: boolean;
+    min?: number;
+    max?: number;
+    enum?: EnumInstance;
+    select?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    accumulate?: any;
+    example?: FieldValue;
+    of?: MapValue;
+    validate?: (value: FieldValue, model: any) => boolean;
+    text?: "search" | "filter";
+    meta?: Metadata;
+}
+export declare const fieldPresets: readonly ["email", "password", "url"];
+export type FieldPreset = (typeof fieldPresets)[number];
+declare class FieldInfo<FieldType extends "property" | "hidden" | "resolve" = any, Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never> {
+    readonly value: Value;
+    readonly type: ConstantFieldTypeInput;
+    readonly option: ConstantFieldProps;
+    explicitType: ExplicitType;
+    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, {
+        [key: string]: any;
+    }>;
+}
+interface ConstantFieldBuildProps<FieldType extends "property" | "hidden" | "resolve" = any, FieldValue = any, MapValue = any, Metadata = any, Nullable extends boolean = boolean> {
+    nullable: Nullable;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    default: FieldValue | ((doc: {
+        id: string;
+    }) => FieldValue);
+    type?: FieldPreset;
+    fieldType: FieldType;
+    immutable: boolean;
+    min?: number;
+    max?: number;
+    enum?: EnumInstance;
+    select: boolean;
+    minlength?: number;
+    maxlength?: number;
+    accumulate?: any;
+    example?: FieldValue;
+    of?: MapValue;
+    validate?: (value: FieldValue, model: any) => boolean;
+    text?: "search" | "filter";
+    modelRef: ConstantCls;
+    arrDepth: number;
+    optArrDepth: number;
+    meta: Metadata;
+}
+export interface FieldProps extends ConstantFieldBuildProps {
+    isClass: boolean;
+    isScalar: boolean;
+    isArray: boolean;
+    isMap: boolean;
+}
+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;
+};
+/** Runtime metadata for a single Akan constant field. */
+export declare class ConstantField<FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve", Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+    [key: string]: any;
+}> implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata> {
+    static getBaseModelField(): FieldObject;
+    static getBaseInsightField(): FieldObject;
+    readonly nullable: Nullable;
+    readonly ref?: string;
+    readonly refPath?: string;
+    readonly refType?: "child" | "parent" | "relation";
+    readonly default: FieldValue | ((doc: {
+        id: string;
+    }) => FieldValue);
+    readonly type?: FieldPreset;
+    readonly fieldType: FieldType;
+    readonly immutable: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly enum?: EnumInstance;
+    readonly select: boolean;
+    readonly minlength?: number;
+    readonly maxlength?: number;
+    readonly accumulate?: any;
+    readonly example?: FieldValue;
+    readonly of?: MapValue;
+    readonly validate?: (value: FieldValue, model: any) => boolean;
+    readonly text?: "search" | "filter";
+    readonly modelRef: ConstantCls;
+    readonly arrDepth: number;
+    readonly optArrDepth: number;
+    readonly meta: Metadata;
+    constructor(props: ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>);
+    static fromFieldInfo<FieldType extends "property" | "hidden" | "resolve" = any, Value extends ConstantFieldTypeInput | null = null, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+        [key: string]: any;
+    }>(fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue>): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, Metadata>;
+    get isClass(): boolean;
+    get isScalar(): boolean;
+    get isArray(): boolean;
+    get isMap(): boolean;
+    getProps(): FieldProps;
+}
+export interface FieldObject {
+    [key: string]: ConstantField;
+}
+type FieldOption<Value extends ConstantFieldTypeInput, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Metadata extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, _FieldToValue = FieldToValue<Value, MapValue> | null | undefined> = Omit<ConstantFieldProps<"property" | "hidden" | "resolve", _FieldToValue, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select"> | Omit<ConstantFieldProps<"property" | "hidden" | "resolve", SingleValue<_FieldToValue>, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select">[];
+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<"hidden", Value | null, ExplicitType | null, MapValue>;
+};
+/** 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 type FieldBuilder = typeof field;
+export type FieldResolver = typeof resolve;
+export {};

package/types/constant/getDefault.d.ts

@@ -0,0 +1,3 @@
+import type { FieldObject } from ".";
+import type { DefaultOf } from "./types.d.ts";
+export declare const getDefault: <T>(fieldObj: FieldObject) => DefaultOf<T>;

package/types/constant/immerify.d.ts

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

package/types/constant/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./constantRegistry.d.ts";
+export * from "./crystalize.d.ts";
+export * from "./deserialize.d.ts";
+export * from "./fieldInfo.d.ts";
+export * from "./getDefault.d.ts";
+export * from "./immerify.d.ts";
+export * from "./purify.d.ts";
+export * from "./serialize.d.ts";
+export * from "./types.d.ts";
+export * from "./via.d.ts";

package/types/constant/purify.d.ts

@@ -0,0 +1,12 @@
+import { type Dayjs, type GetStateObject, type Upload } from "akanjs/base";
+import { type BaseObject, type ConstantCls, type DefaultOf } 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]>;
+} & {
+    [K in StateKeys as null extends T[K] ? K : never]?: Purified<T[K]> | undefined;
+};
+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 {};

package/types/constant/serialize.d.ts

@@ -0,0 +1,11 @@
+import { type Dayjs, type PrimitiveScalar } from "akanjs/base";
+import type { ConstantCls } 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 }: {
+    nullable?: boolean;
+    key?: string;
+}) => object[] | null;

package/types/constant/types.d.ts

@@ -0,0 +1,77 @@
+import { type Dayjs, type GetStateObject } from "akanjs/base";
+export type QueryOf<T = any> = any;
+export type ConstantType = "input" | "object" | "full" | "light" | "insight" | "scalar";
+type ObjectToId<O> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? Dayjs : O extends object ? DocumentModel<O> : O;
+type Docify<T, _StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
+    [K in _StateKeys as null extends T[K] ? never : K]: ObjectToId<T[K]>;
+} & {
+    [K in _StateKeys as null extends T[K] ? K : never]?: ObjectToId<Exclude<T[K], null>> | undefined;
+};
+export type DocumentModel<T> = T extends (infer S)[] ? DocumentModel<S>[] : T extends string | number | boolean | Dayjs | File ? T : T extends Map<infer K, infer V> ? Map<K, DocumentModel<V>> : Docify<T>;
+export type FieldState<T> = T extends {
+    id: string;
+} ? T | null : T;
+export type DefaultOf<S> = GetStateObject<{
+    [K in keyof S]: FieldState<S[K]>;
+}>;
+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>;
+export declare class BaseObject {
+    id: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+}
+export declare class BaseInsight {
+    count: number;
+}
+export interface ProtoFile {
+    id: string;
+    filename: string;
+    abstractData: string | null;
+    imageSize: [number, number];
+    progress: number | null;
+    url: string;
+    size: number;
+    status: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+    mimetype: string;
+    encoding: string;
+    origin: string | null;
+    lastModifiedAt: Dayjs;
+}
+export interface ProtoAppInfo {
+    appId: string | null;
+    appName: string;
+    deviceId: string | null;
+    platform: "ios" | "android" | null;
+    major: number;
+    minor: number;
+    patch: number;
+    branch: string;
+    buildNum: string | null;
+    versionOs: string | null;
+    isEmulator: boolean | null;
+}
+export interface ProtoPatch {
+    source: ProtoFile;
+    build: ProtoFile;
+    appBuild: ProtoFile | null;
+    status: "active" | "expired";
+    at: Dayjs;
+}
+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 declare const unsetDate: Dayjs;
+export declare const MAX_INT = 2147483647;
+declare const Responsive_base: import("akanjs/base").EnumInstance<"responsive", "xl" | "lg" | "md" | "sm" | "xs">;
+export declare class Responsive extends Responsive_base {
+}
+export declare const responsiveWidths: readonly [1200, 992, 768, 576, 0];
+export {};

package/types/constant/via.d.ts

@@ -0,0 +1,52 @@
+import { type Cls, type EnumInstance, FIELD_META, type MergeAllKeyOfObjects, type MergeAllTypes } from "akanjs/base";
+import { 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";
+type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
+type OmitBase<T> = Omit<T, BaseFields>;
+export interface ConstantMethods<Schema = any> {
+    set: (obj: Partial<Schema>) => this;
+}
+export interface ConstantStatics<Schema = any, FieldObj extends FieldObject = FieldObject> {
+    [FIELD_META]: FieldObj;
+    getDefault: () => DefaultOf<Schema>;
+    purify: PurifyFunc<Schema>;
+    modelType: ConstantType;
+    children: Set<ConstantCls>;
+    relations: Set<ConstantCls>;
+    enums: Set<EnumInstance>;
+    text: {
+        search: Set<string>;
+        filter: Set<string>;
+        children: {
+            search: Set<string>;
+            filter: Set<string>;
+        };
+    };
+}
+export type ConstantCls<Schema = any, FieldObj extends FieldObject = FieldObject> = (new (obj?: Partial<Schema>) => Schema & ConstantMethods<Schema>) & ConstantStatics<Schema, FieldObj>;
+declare global {
+    interface DateConstructor extends ConstantStatics<unknown> {
+    }
+    interface StringConstructor extends ConstantStatics<unknown> {
+    }
+    interface BooleanConstructor extends ConstantStatics<unknown> {
+    }
+    interface MapConstructor extends ConstantStatics<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, {
+    [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, {
+    [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, {
+    [FIELD_META]: ObjFieldObj;
+}>, lightModelRef: Cls<Light, {
+    [FIELD_META]: LightFieldObj;
+}>, resolveField: ResolveField, ...fullModelRefs: FullModels): ConstantCls<_Schema, _FieldObj>;
+export {};

package/types/constant.d.ts

@@ -0,0 +1 @@
+export * from "./constant/index.d.ts";

package/types/dictionary/base.dictionary.d.ts

@@ -0,0 +1 @@
+export declare const baseDictionary: import("./dictInfo.d.ts").ServiceDictInfo<[string, string], string, never, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">;