akanjs 2.2.4 → 2.2.6

package/types/store/stateInfo.d.ts

@@ -0,0 +1,23 @@
+import type { EnumInstance, PrimitiveScalar } from "akanjs/base";
+import type { ConstantFieldTypeInput, PlainTypeToFieldType } from "akanjs/constant";
+export type StateType = "normal" | "storage" | "cookie" | "param" | "searchParam";
+export interface StateProps<FieldValue = any, MapValue = any, Nullable extends boolean = false> {
+    nullable: Nullable;
+    default?: FieldValue | ((doc: {
+        id: string;
+    }) => FieldValue);
+    enum?: EnumInstance;
+    of?: MapValue;
+}
+export declare class StateInfo<Type extends StateType = StateType, Value extends ConstantFieldTypeInput = any, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Nullable extends boolean = boolean> {
+    readonly type: Type;
+    readonly value: Value;
+    readonly option: StateProps<Value, MapValue, Nullable>;
+    constructor(type: Type, value: Value, option?: StateProps<Value, MapValue, Nullable>);
+}
+export declare const buildState: {
+    storage: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Nullable extends boolean = false>(value: Value, option?: StateProps<Value, MapValue, Nullable>) => StateInfo<"storage", Value, MapValue, Nullable>;
+    cookie: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Nullable extends boolean = false>(value: Value, option?: StateProps<Value, MapValue, Nullable>) => StateInfo<"cookie", Value, MapValue, Nullable>;
+    param: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Nullable extends boolean = false>(value: Value, option?: StateProps<Value, MapValue, Nullable>) => StateInfo<"param", Value, MapValue, Nullable>;
+    searchParam: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never, Nullable extends boolean = false>(value: Value, option?: StateProps<Value, MapValue, Nullable>) => StateInfo<"searchParam", Value, MapValue, Nullable>;
+};

package/types/store/store.d.ts

@@ -0,0 +1,36 @@
+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 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 {
+    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 & {
+    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>;
+    };
+}, {
+    readonly type: "module";
+    readonly refName: RefName;
+    [STATE_META]: State;
+    [STATE_INIT_META]: StateInitializerMap;
+    [STATE_DERIVED_META]: StateDerivedMeta;
+    [ACTION_META]: {
+        [key: string]: (...args: any[]) => any;
+    };
+    slice: {
+        [key: string]: SerializedSlice;
+    };
+    _slice: SlceCls[typeof SLICE_META];
+}>;
+export type ModelStore<Sig extends ClientSignal<any, any, any> | string, WritableState, Action, DerivedState = unknown> = Sig extends string ? StoreCls<Sig, WritableState, Action, any, DerivedState> : Sig extends ClientSignal<any, any, any> ? StoreCls<Sig["refName"], WritableState & DefaultState<Sig["_slice"]>, Action & DefaultAction<Sig["_slice"]>, Sig["_slice"], DerivedState> : never;
+export type StoreReturn<Sig extends ClientSignal<any, any, any> | string, WritableState, LibStores extends StoreCls[], // TODO: Change Type for LibStores' state and action
+DerivedState = unknown, _LibState = MergeAllKeyOfObjects<LibStores, typeof STATE_META>, _LibAction = MergeAllActionTypes<LibStores, keyof SetGet | "slice">> = ModelStore<Sig, WritableState & _LibState, _LibAction, DerivedState>;
+type StateFactory<State> = (builder: WritableStateBuilder) => State;
+type DerivedStateFactory<WritableState, DerivedState> = (builder: DerivedStateBuilder<WritableState>) => DerivedState;
+export declare function store<Sig extends ClientSignal<any, any, any> | string, State, LibStores extends StoreCls[]>(sigRefOrRefName: Sig, state: StateFactory<State>, ...libStores: LibStores): StoreReturn<Sig, WritableStateOf<State>, LibStores>;
+export declare function store<Sig extends ClientSignal<any, any, any> | string, State, DerivedState, LibStores extends StoreCls[]>(sigRefOrRefName: Sig, state: StateFactory<State>, derivedState: DerivedStateFactory<WritableStateOf<State>, DerivedState>, ...libStores: LibStores): StoreReturn<Sig, WritableStateOf<State>, LibStores, DerivedStateOf<DerivedState>>;
+export {};

package/types/store/storeInstance.d.ts

@@ -0,0 +1,38 @@
+import type { RefObject } from "react";
+import type { RootStoreCls } from "./rootStore.d.ts";
+type StoreStateRecord = Record<string, unknown>;
+type StoreAction = (...args: unknown[]) => unknown;
+export type ReactAPI = {
+    useSyncExternalStore: <T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+    useRef: <T>(initialValue: T) => {
+        current: T;
+    };
+    useEffect: (effect: () => (() => void) | void, deps?: any[]) => void;
+};
+export declare class StoreInstance {
+    #private;
+    get: () => StoreStateRecord;
+    set: (stateOrUpdater: StoreStateRecord | ((state: StoreStateRecord) => void)) => void;
+    subscribe: (listener: () => void) => () => void;
+    sub: {
+        (listener: (state: StoreStateRecord, prev: StoreStateRecord) => void): () => void;
+        <U>(selector: (state: StoreStateRecord) => U, listener: (state: U, prev: U) => void, options?: {
+            equalityFn?: (a: U, b: U) => boolean;
+            fireImmediately?: boolean;
+        }): () => void;
+    };
+    sel: <U>(selector: (state: StoreStateRecord) => U, equals?: (a: U, b: U) => boolean) => U;
+    ref: <U>(selector: (state: StoreStateRecord) => U) => RefObject<U>;
+    use: {
+        [key: string]: () => unknown;
+    };
+    do: {
+        [key: string]: StoreAction;
+    };
+    slice: {
+        [key: string]: unknown;
+    };
+    constructor(store?: RootStoreCls);
+    addStore(store: RootStoreCls): this;
+}
+export {};

package/types/store/storeRegistry.d.ts

@@ -0,0 +1,13 @@
+import { type MergeAllKeyOfObjects, type MergeAllKeyOfTypes, type MergeAllTypes, STATE_META } from "akanjs/base";
+import type { RootStoreCls } from "./rootStore.d.ts";
+import type { StoreCls } from "./store.d.ts";
+export type { ReactAPI } from "./storeInstance.d.ts";
+import type { SetGet } from "./types.d.ts";
+import type { WithSelectors } from "./withSelector.d.ts";
+export declare class StoreRegistry {
+    #private;
+    static register<StrCls extends StoreCls>(store: StrCls): StrCls;
+    static get(refName: string): StoreCls | undefined;
+    static merge<RefName extends string, StoreClses extends (StoreCls | RootStoreCls)[]>(refName: RefName, ...stores: StoreClses): RootStoreCls<RefName, MergeAllKeyOfObjects<StoreClses, typeof STATE_META>, MergeAllTypes<StoreClses, keyof SetGet | "slice">, MergeAllKeyOfTypes<StoreClses, "slice">, MergeAllKeyOfObjects<StoreClses, "_slice">>;
+    static build<RtStoreCls extends RootStoreCls>(store: RtStoreCls): WithSelectors<RtStoreCls>;
+}

package/types/store/types.d.ts

@@ -0,0 +1,42 @@
+import type { DefaultOf } from "akanjs/constant";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+import type { SliceInfo } from "akanjs/signal";
+import type { SliceAction } from "./action.d.ts";
+import type { SliceState } from "./state.d.ts";
+export interface Submit {
+    disabled: boolean;
+    loading: boolean;
+    times: number;
+}
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type PickFunc<State, F extends keyof State = IsAny<State> extends true ? any : keyof State extends never ? any : keyof State> = (...fields: F[]) => {
+    [K in (typeof fields)[number]]: Exclude<State[K], null | undefined | "loading">;
+};
+export interface SetGet<State = any> {
+    set: (setState: Partial<State> | ((state: State) => void)) => void;
+    get: () => State;
+    pick: PickFunc<State>;
+}
+export interface SetGetWritable<WritableState = any, State = WritableState> {
+    set: (setState: Partial<WritableState> | ((state: WritableState) => void)) => void;
+    get: () => State;
+    pick: PickFunc<State>;
+}
+export interface SetPick<State = any> {
+    set: (setState: Partial<State> | ((state: State) => void)) => void;
+    pick: PickFunc<State>;
+}
+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 & {
+    refName: RefName;
+    suffix: Suffix;
+    sliceName: SliceName;
+    get: () => State;
+    set: (setState: Partial<State> | ((state: State) => void)) => void;
+};
+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>;
+export {};

package/types/store/withSelector.d.ts

@@ -0,0 +1,42 @@
+import type { Prettify } from "akanjs/base";
+import type { FieldState } from "akanjs/constant";
+import type { RefObject } from "react";
+import type { RootStoreCls } from "./rootStore.d.ts";
+import type { SliceStateAction } from "./types.d.ts";
+type SetKey<Key extends string> = `set${Capitalize<Key>}`;
+export type WithSelectors<RtStoreCls extends RootStoreCls> = RtStoreCls extends RootStoreCls<any, infer WritableState, infer Action, infer InternalSliceObj, any, any, infer State> ? WithSelectorsOf<State, WritableState, Action, InternalSliceObj> : never;
+type WithSelectorsOf<State, WritableState, Action, InternalSliceObj> = {
+    sub: {
+        (listener: (state: State, prev: State) => void): () => void;
+        <U>(selector: (state: State) => U, listener: (state: U, prev: U) => void, options?: {
+            equalityFn?: (a: U, b: U) => boolean;
+            fireImmediately?: boolean;
+        }): () => void;
+    };
+    ref: <U>(selector: (state: State) => U) => RefObject<U>;
+    sel: <U>(selector: (state: State) => U, equals?: (a: U, b: U) => boolean) => U;
+    use: {
+        [K in keyof State]: () => State[K];
+    };
+    do: Action & {
+        [K in keyof WritableState as K extends string ? SetKey<K> : never]: (value: FieldState<WritableState[K]>) => void;
+    };
+    get: () => State;
+    set: (state: Partial<WritableState> | ((state: WritableState) => any)) => void;
+    slice: {
+        [K in keyof InternalSliceObj]: InternalSliceObj[K] extends SliceStateAction<infer RefName, infer Suffix, infer SliceName, infer State, infer Action> ? SliceSelectors<RefName, State, Action> : never;
+    };
+};
+export interface SliceSelectors<RefName extends string, State, Action> {
+    refName: RefName;
+    use: {
+        [K in keyof State]: () => State[K];
+    };
+    do: Prettify<{
+        [K in keyof Action]: Action[K];
+    } & {
+        [K in keyof State as K extends string ? SetKey<K> : never]: (value: FieldState<State[K]>) => void;
+    }>;
+    get: () => State;
+}
+export {};

package/types/store.d.ts

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

package/types/test/index.d.ts

@@ -0,0 +1,4 @@
+export { sample } from "./sample.d.ts";
+export { sampleOf } from "./sampleOf.d.ts";
+export { configureSignalTest, getOrSetupSignalTestContext, getOrSetupSignalTestFetch, getSignalTestContext, getSignalTestFetch, hasSignalTestContext, type SignalTestContext, type SignalTestOptions, type SignalTestTarget, setupSignalTestTarget, terminateSignalTestContext, } from "./signalTestRuntime.d.ts";
+export { TestServer, type TestServerOptions } from "./testServer.d.ts";

package/types/test/playwright.config.base.d.ts

@@ -0,0 +1,9 @@
+import { type PlaywrightTestConfig } from "@playwright/test";
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export declare const withBase: (filename: string, config?: PlaywrightTestConfig) => PlaywrightTestConfig<{}, {}>;

package/types/test/playwright.pageAgent.d.ts

@@ -0,0 +1,12 @@
+import { type Page, test } from "@playwright/test";
+export { expect } from "@playwright/test";
+export { test };
+export declare class PageAgent {
+    #private;
+    readonly page: Page;
+    constructor(page: Page);
+    goto(path: string): Promise<void>;
+    waitForPathChange(path?: string): Promise<unknown>;
+    wait(ms?: number): Promise<void>;
+    url(): string;
+}

package/types/test/sample.d.ts

@@ -0,0 +1,15 @@
+import { type Dayjs } from "akanjs/base";
+import Chance from "chance";
+export declare const sample: Chance.Chance & {
+    dayjs: (opt?: {
+        string?: boolean | undefined;
+        american?: boolean | undefined;
+        year?: number | undefined;
+        month?: number | undefined;
+        day?: number | undefined;
+        min?: Dayjs | undefined;
+        max?: Dayjs | undefined;
+    }) => Dayjs;
+    pick: <T = unknown>(arr: T[] | readonly T[]) => T;
+    picks: <T>(arr: T[] | readonly T[], count?: number, allowDuplicate?: boolean) => T[];
+};

package/types/test/sampleOf.d.ts

@@ -0,0 +1,5 @@
+import type { BaseObject, ConstantCls, DocumentModel } from "akanjs/constant";
+export type SampleOf<Model> = DocumentModel<{
+    [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>;
+}>;
+export declare const sampleOf: <Model>(modelRef: ConstantCls<Model>) => DocumentModel<{ [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>; }>;

package/types/test/signalTest.preload.d.ts

@@ -0,0 +1 @@
+export {};

package/types/test/signalTestRuntime.d.ts

@@ -0,0 +1,29 @@
+import type { BackendEnv } from "akanjs/base";
+import type { FetchProxy } from "akanjs/fetch";
+import type { AkanLib } from "akanjs/server";
+import { type TestServerOptions } from "./testServer.d.ts";
+export interface SignalTestTarget {
+    type: "app" | "lib";
+    name: string;
+    env: BackendEnv;
+    fetch: FetchProxy;
+    libs: AkanLib[];
+}
+export interface SignalTestContext<Fetch = FetchProxy> {
+    fetch: Fetch;
+    target: SignalTestTarget;
+    terminate: () => Promise<void>;
+}
+export type SignalTestOptions = Pick<TestServerOptions, "databaseMode" | "workerId" | "port" | "serverMode">;
+export declare const hasSignalTestContext: () => boolean;
+export declare const getSignalTestContext: <Fetch = FetchProxy>() => SignalTestContext<Fetch>;
+export declare const getSignalTestFetch: <Fetch = FetchProxy>() => Fetch;
+export declare const getOrSetupSignalTestContext: <Fetch = FetchProxy>() => Promise<SignalTestContext<Fetch>>;
+export declare const getOrSetupSignalTestFetch: <Fetch = FetchProxy>() => Promise<Fetch>;
+export declare const configureSignalTest: (options: SignalTestOptions) => void;
+export declare const terminateSignalTestContext: () => Promise<void>;
+export declare const setupSignalTestTarget: <Fetch = FetchProxy>({ type, name, libNames, }?: {
+    type?: "app" | "lib";
+    name?: string;
+    libNames?: string[];
+}, options?: SignalTestOptions) => Promise<SignalTestContext<Fetch>>;

package/types/test/testServer.d.ts

@@ -0,0 +1,26 @@
+import type { BackendEnv } from "akanjs/base";
+import { type AkanLib } from "akanjs/server";
+type TestDatabaseMode = "memory" | "tempFile";
+export interface TestServerOptions {
+    workerId?: number;
+    port?: number;
+    databaseMode?: TestDatabaseMode;
+    serverMode?: "federation" | "batch" | "all";
+    listen?: boolean;
+    web?: boolean;
+}
+export declare class TestServer {
+    #private;
+    workerId: number;
+    static initClient(env: BackendEnv, workerId?: number): void;
+    static applyProcessEnv(env: BackendEnv, { workerId, port, serverMode, }?: {
+        workerId?: number;
+        port?: number;
+        serverMode?: "federation" | "batch" | "all";
+    }): void;
+    constructor(env: BackendEnv, libs: AkanLib | AkanLib[], options?: TestServerOptions);
+    init(): Promise<void>;
+    cleanup(): Promise<void>;
+    terminate(): Promise<void>;
+}
+export {};

package/types/test.d.ts

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

package/types/ui/BottomSheet.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+interface BottomSheetProps {
+    open: boolean;
+    onCancel: () => void;
+    children: ReactNode;
+    type: "full" | "half";
+}
+export interface BottomSheetRef {
+    open: () => void;
+    close: () => void;
+}
+export declare const BottomSheet: import("react").ForwardRefExoticComponent<BottomSheetProps & import("react").RefAttributes<BottomSheetRef>>;
+export {};

package/types/ui/Button.d.ts

@@ -0,0 +1,11 @@
+import type React from "react";
+import { type ButtonHTMLAttributes } from "react";
+export type ButtonProps<Result> = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & {
+    /** Async-aware click handler. Call onError to show the localized error state without throwing. */
+    onClick: (e: React.MouseEvent<HTMLButtonElement>, { onError }: {
+        onError: (error: string) => void;
+    }) => Promise<Result> | Result;
+    /** Called after the button briefly enters success state. */
+    onSuccess?: (result: Result) => void;
+};
+export declare const Button: <Result = unknown>({ className, children, onClick, onSuccess, ...rest }: ButtonProps<Result>) => import("react/jsx-runtime").JSX.Element;

package/types/ui/ClientSide.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+export interface ClientSideProps {
+    /** Content that should render inside a React Suspense boundary on the client. */
+    children: ReactNode;
+    /** Optional Suspense fallback. */
+    loading?: ReactNode;
+}
+export declare const ClientSide: ({ children, loading }: ClientSideProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Clipboard.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from "react";
+export interface ClipboardProps {
+    text?: string;
+    clipboardMessage?: string;
+    className?: string;
+}
+export declare const Clipboard: ({ text, className }: ClipboardProps) => ReactElement;

package/types/ui/Constant/Doc.d.ts

@@ -0,0 +1,29 @@
+import { type DatabaseSchema, getConstantSchemaDoc, type ScalarSchema } from "./schemaDoc.d.ts";
+declare function Doc(): import("react/jsx-runtime").JSX.Element;
+declare namespace Doc {
+    var Zone: ({ models, scalars, enums, openAll }: ZoneProps) => import("react/jsx-runtime").JSX.Element;
+    var Print: ({ models, scalars, enums }: ZoneProps) => import("react/jsx-runtime").JSX.Element;
+    var Model: ({ refName, database: databaseProp, openAll }: ModelProps) => import("react/jsx-runtime").JSX.Element | null;
+    var Scalar: ({ refName, scalar: scalarProp, openAll }: ScalarProps) => import("react/jsx-runtime").JSX.Element | null;
+    var Enum: ({ enums }: EnumProps) => import("react/jsx-runtime").JSX.Element;
+}
+export default Doc;
+interface ZoneProps {
+    models?: string[];
+    scalars?: string[];
+    enums?: string[];
+    openAll?: boolean;
+}
+interface ModelProps {
+    refName?: string;
+    database?: DatabaseSchema;
+    openAll?: boolean;
+}
+interface ScalarProps {
+    refName?: string;
+    scalar?: ScalarSchema;
+    openAll?: boolean;
+}
+interface EnumProps {
+    enums?: ReturnType<typeof getConstantSchemaDoc>["enums"];
+}

package/types/ui/Constant/Mermaid.d.ts

@@ -0,0 +1,8 @@
+export interface MermaidProps {
+    chart: string;
+    title?: string;
+    className?: string;
+    highlightNodes?: string[];
+    onSelectNode?: (nodeId: string) => void;
+}
+export declare const Mermaid: ({ chart, title, className, highlightNodes, onSelectNode }: MermaidProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/Constant/index.d.ts

@@ -0,0 +1,6 @@
+import Doc from "./Doc.d.ts";
+export * from "./schemaDoc.d.ts";
+export declare const Constant: {
+    Doc: typeof Doc;
+    Mermaid: ({ chart, title, className, highlightNodes, onSelectNode }: import("./Mermaid.d.ts").MermaidProps) => import("react/jsx-runtime").JSX.Element;
+};

package/types/ui/Constant/schemaDoc.d.ts

@@ -0,0 +1,84 @@
+import { type EnumInstance } from "akanjs/base";
+import { type ConstantCls, type ConstantField } from "akanjs/constant";
+export declare const databaseModelVariants: readonly ["input", "object", "full", "light", "insight"];
+export type DatabaseModelVariant = (typeof databaseModelVariants)[number];
+export interface ConstantSchemaOptions {
+    models?: string[];
+    scalars?: string[];
+    enums?: string[];
+}
+export interface ConstantSchemaDoc {
+    databases: DatabaseSchema[];
+    scalars: ScalarSchema[];
+    enums: EnumSchema[];
+    relations: RelationSchema[];
+}
+export interface DatabaseSchema {
+    kind: "database";
+    refName: string;
+    modelName: string;
+    variants: Record<DatabaseModelVariant, ModelVariantSchema>;
+}
+export interface ScalarSchema {
+    kind: "scalar";
+    refName: string;
+    modelName: string;
+    modelRef: ConstantCls;
+    fields: FieldSchema[];
+}
+export interface ModelVariantSchema {
+    refName: string;
+    variant: DatabaseModelVariant | "scalar";
+    modelName: string;
+    modelRef: ConstantCls;
+    fields: FieldSchema[];
+}
+export interface EnumSchema {
+    key: string;
+    refName: string;
+    typeName: string;
+    values: (string | number)[];
+    enumRef: EnumInstance;
+    usedBy: EnumUsage[];
+}
+export interface EnumUsage {
+    refName: string;
+    variant: DatabaseModelVariant | "scalar";
+    fieldKey: string;
+}
+export interface RelationSchema {
+    sourceRefName: string;
+    sourceVariant: DatabaseModelVariant | "scalar";
+    targetRefName: string;
+    targetKind: "database" | "scalar";
+    fieldKey: string;
+    relationType: string;
+    external: boolean;
+}
+export interface FieldSchema {
+    key: string;
+    typeLabel: string;
+    typeRefName?: string;
+    typeKind: "primitive" | "database" | "scalar" | "map" | "unknown";
+    required: boolean;
+    nullable: boolean;
+    arrDepth: number;
+    fieldType: "property" | "hidden" | "resolve";
+    select: boolean;
+    immutable: boolean;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    relationLabel?: string;
+    enumRefName?: string;
+    enumValues?: (string | number)[];
+    defaultLabel?: string;
+    exampleLabel?: string;
+    constraints: string[];
+    text?: "search" | "filter";
+    meta: Record<string, unknown>;
+    raw: ConstantField;
+}
+export declare const getConstantSchemaDoc: (options?: ConstantSchemaOptions) => ConstantSchemaDoc;
+export declare const getDefaultVariant: (database: DatabaseSchema) => ModelVariantSchema;
+export declare const getVariantTitle: (variant: DatabaseModelVariant | "scalar") => string;

package/types/ui/Constant.d.ts

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

package/types/ui/Copy.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+export interface CopyProps {
+    /** Text copied to the clipboard. Defaults to an empty string. */
+    text?: string;
+    /** Success message shown through the global store message helper. */
+    copyMessage?: string;
+    /** Copy trigger element. */
+    children: ReactNode;
+}
+export declare const Copy: ({ text, copyMessage, children }: CopyProps) => import("react/jsx-runtime").JSX.Element;

package/types/ui/CsrImage.d.ts

@@ -0,0 +1,18 @@
+import type { ProtoFile } from "akanjs/constant";
+import type { ImgHTMLAttributes } from "react";
+type CsrImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src"> & {
+    src?: string;
+    file?: ProtoFile | {
+        url: string;
+        imageSize: [number, number];
+        abstractData?: string | null;
+    } | null;
+    abstractData?: string;
+    priority?: boolean;
+    preload?: boolean;
+    quality?: number;
+    unoptimized?: boolean;
+    fill?: boolean;
+};
+export declare const CsrImage: ({ src, file, className, abstractData, ...props }: CsrImageProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/Data/CardList.d.ts

@@ -0,0 +1,36 @@
+import { type DataAction, type DataColumn } from "akanjs/client";
+import type { FilterInstance } from "akanjs/document";
+import type { FetchInitForm, SliceMeta } from "akanjs/fetch";
+import { type ReactNode } from "react";
+type DataItemProps<T extends string, M extends {
+    id: string;
+}, L extends {
+    id: string;
+}> = {
+    [key in T]: L;
+} & {
+    slice: SliceMeta;
+};
+interface CardListProps<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Filter extends FilterInstance> {
+    className?: string;
+    cardListClassName?: string;
+    init?: FetchInitForm<Input, Filter>;
+    slice: SliceMeta;
+    columns: DataColumn<any>[];
+    actions?: DataAction[] | ((item: Light, idx: number) => DataAction[]);
+    renderItem: (args: DataItemProps<T, Full, Light>) => ReactNode;
+    renderLoading?: () => ReactNode;
+    renderTemplate?: (props: any) => ReactNode | null;
+    renderView?: (model: Full) => ReactNode | null;
+    renderTitle?: (model: Full) => string | ReactNode;
+}
+export default function CardList<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Filter extends FilterInstance>({ className, cardListClassName, init, slice, actions, columns, renderItem, renderLoading, renderTemplate, renderView, renderTitle, }: CardListProps<T, Input, Full, Light, Filter>): import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/Data/Dashboard.d.ts

@@ -0,0 +1,11 @@
+import type { SliceMeta } from "akanjs/fetch";
+export interface DashboardProps<T extends string, State> {
+    className?: string;
+    summary: Record<string, unknown>;
+    slice: SliceMeta;
+    queryMap: Record<string, unknown>;
+    columns?: string[];
+    presents?: string[];
+    hidePresents?: boolean;
+}
+export default function Dashboard<T extends string, State>({ className, summary, slice, queryMap, columns, presents, hidePresents, }: DashboardProps<T, State>): import("react/jsx-runtime").JSX.Element;

package/types/ui/Data/Insight.d.ts

@@ -0,0 +1,9 @@
+import type { SliceMeta } from "akanjs/fetch";
+interface InsightProps<T extends string, Insight> {
+    className?: string;
+    insight: Insight;
+    slice: SliceMeta;
+    columns?: (keyof Insight)[];
+}
+export default function Insight<T extends string, Insight>({ className, insight, slice, columns, }: InsightProps<T, Insight>): import("react/jsx-runtime").JSX.Element;
+export {};