import { Schema, SchemaProp, SchemaType, SchemaPropTypes, SchemaProps, SchemaTypes, SchemaPropTypeMap } from '@based/schema';
import { ComponentType, ReactNode } from 'react';
export type SchemaComponent = (data: BasedNode | BasedNode[], schemaProp: UiSchemaProp, schema: UiSchema) => ReactNode;
export type SchemaPropsToComponentMap = Record<SchemaPropTypes, SchemaComponent>;
export type BasedNode = {
    id: number;
} & Record<string, any>;
export type UiMeta = {
    title?: string;
    width?: number;
    align?: 'left' | 'center' | 'right';
    render?: (value: any, values?: BasedNode) => ReactNode;
    renderAs?: ComponentType<{
        name: string;
        schemaProp: any;
        value: any;
        onChange?: (value: any, name: string) => void;
    }>;
    hide?: boolean;
    note?: {
        title: string;
        description: string;
    };
    default?: unknown;
    key?: any;
    props?: UiPropsInput<StripId<NonStrictProps>>;
};
type StripId<T> = Omit<T, 'id'>;
type ExpandEnumArrayResolved<T> = T extends readonly (infer E)[] ? Omit<SchemaPropTypeMap['enum'], 'enum' | 'type'> & {
    type: 'enum';
    enum: E[];
} : never;
type NormalizePropResolved<T> = T extends {
    type?: 'object';
    props: infer P;
} ? Omit<T, 'props'> & {
    props: UiPropsResolved<P>;
} : T extends {
    type?: 'set';
    items: infer I;
} ? Omit<T, 'items'> & {
    items: UiSchemaProp<I>;
} : T extends SchemaPropTypes ? SchemaPropTypeMap[T] : T extends readonly any[] ? ExpandEnumArrayResolved<T> : T;
type WithUiMetaResolved<X> = X extends object ? X & UiMeta : UiMeta;
export type UiSchemaProp<T = SchemaProp> = WithUiMetaResolved<NormalizePropResolved<T>>;
export type OverrideUiSchemaProps = Record<string, Partial<UiSchemaProp>>;
type UiPropsResolved<P> = {
    [K in Exclude<keyof P, 'id'>]: UiSchemaProp<P[K]>;
};
type ExpandEnumArrayInput<T> = T extends readonly (infer E)[] ? (Omit<SchemaPropTypeMap['enum'], 'enum' | 'type'> & {
    type: 'enum';
    enum: E[];
}) | T : never;
type NormalizePropInput<T> = T extends {
    type?: 'object';
    props: infer P;
} ? Omit<T, 'props'> & {
    props: UiPropsInput<P>;
} : T extends {
    type?: 'set';
    items: infer I;
} ? Omit<T, 'items'> & {
    items: NormalizePropInput<I>;
} : T extends SchemaPropTypes ? SchemaPropTypeMap[T] | T : T extends readonly any[] ? ExpandEnumArrayInput<T> : T;
type WithUiMetaInput<X> = X extends object ? X & UiMeta : X & UiMeta;
type UiPropsInput<P> = {
    [K in Exclude<keyof P, 'id'>]: WithUiMetaInput<NormalizePropInput<P[K]>>;
};
export type UiSchemaType<T = SchemaType> = {
    key?: any;
    prop?: UiSchemaProp;
} & ((T extends {
    props: infer P;
} ? Omit<T, 'props'> & {
    props: UiPropsInput<P>;
} : never) | (T extends SchemaProps ? UiPropsInput<T> : never));
export type UiSchemaTypes<T = SchemaTypes> = {
    [K in Exclude<keyof T, '_root'>]: UiSchemaType<T[K]>;
} & {
    _root?: never;
};
type NonStrictTypes = SchemaTypes<false>;
type NonStrictProps = SchemaProps<false>;
export type UiSchema = Omit<Schema, 'types' | 'props'> & {
    types?: UiSchemaTypes<NonStrictTypes>;
    props?: UiPropsInput<StripId<NonStrictProps>>;
};
export {};