import type Cion from '@taiyakihitotsu/cion';
import * as typeUtil from './type-util.js';
import type { LispFalsy } from './type-util.js';
import * as compiler from './compiler.js';
import { const as c } from './const.js';
import * as ut from './type-util.js';
import * as fraction from './fraction.js';
export type IsFnForm<P> = [P, Symbol] extends [string, compiler.PrimToTS<P>] ? true : false;
export type _LispString<S extends string> = `'${S}'`;
export type ToLispString<T extends ut.Primitive> = T extends `:${infer K}` ? `:${K}` : T extends string ? [fraction.isRational<T>, _LispString<T>] extends [true, `'${infer N}'`] ? N : _LispString<T> : `${T}`;
type SymSig = {
    [c.FnFlagKey]: true;
};
type Rec = Record<PropertyKey, unknown> | Readonly<Record<PropertyKey, unknown>>;
type Arr = unknown[] | readonly unknown[];
export type DeeplySymSearch<Data> = Data extends SymSig ? true : Data extends [infer F, ...infer T] ? F extends SymSig ? true : F extends Rec | Arr ? false extends DeeplySymSearch<F> ? DeeplySymSearch<T> : true : T extends [] ? false : DeeplySymSearch<T> : Data extends Rec ? DeeplySymSearch<{
    [K in keyof Data]: Data[K];
}[keyof Data]> extends false ? false : true : false;
export type LispWrapedMapWith<T> = {
    [c.SexprKey]: typeUtil.RtoS<T>;
    [c.ContKey]: typeUtil.RtoS<T>;
    [c.FnFlagKey]: DeeplySymSearch<T>;
    [c.ValueKey]: T;
    [c.HofFlag]: false;
};
export declare const putRecord: <V extends Record<PropertyKey, unknown>>(v: V extends (ut.ForceReadRecord<V> extends never ? never : V) ? V : never) => LispWrapedMapWith<V>;
export type LispWrapedVecWith<T extends ut.Tuple> = {
    [c.SexprKey]: typeUtil.VtoS<T>;
    [c.ContKey]: typeUtil.VtoS<T>;
    [c.FnFlagKey]: DeeplySymSearch<T>;
    [c.ValueKey]: T;
    [c.HofFlag]: false;
};
export declare const putVec: <V extends unknown[] | readonly unknown[], Vpre extends (ut.ForceTuple<V> extends never ? V["length"] extends 0 ? V : never : V), Vpass extends (V extends ut.Tuple ? V : never)>(v: V extends Vpre ? V : never) => LispWrapedVecWith<Vpass>;
export type LispWrapedFnValue<Pre, T> = {
    fn: T;
    pre: Pre;
};
export type LispWrapedFnWith<Pre, F, T> = {
    [c.SexprKey]: F;
    [c.ContKey]: F;
    [c.FnFlagKey]: false;
    [c.ValueKey]: LispWrapedFnValue<Pre, T>;
    [c.HofFlag]: false;
};
export declare const putFn1: <Pre, F>() => <T>(f: T) => LispWrapedFnWith<Pre, F, T>;
export type LispWrapedPrimWith<T extends ut.Primitive, R extends ut.Primitive> = {
    [c.SexprKey]: ToLispString<T>;
    [c.ContKey]: ToLispString<T>;
    [c.ValueKey]: R;
    [c.FnFlagKey]: IsFnForm<T>;
    [c.HofFlag]: false;
};
export declare const putPrim: <V extends ut.Primitive, R extends ut.Primitive = (fraction.isRational<V> extends true ? number : V)>(v: V) => LispWrapedPrimWith<V, R>;
export declare const putSym: <Sym extends string, V>(s: Sym, v: V) => {
    [c.SexprKey]: Sym;
    [c.ContKey]: Sym;
    [c.FnFlagKey]: true;
    [c.ValueKey]: Symbol;
    [c.HofFlag]: false;
};
export declare const putNil: <N extends (null | undefined)>(n: N) => {
    [c.SexprKey]: "nil";
    [c.ContKey]: "nil";
    [c.FnFlagKey]: false;
    [c.ValueKey]: N;
    [c.HofFlag]: false;
};
export declare const tid: <T extends string>() => <U extends {
    [c.SexprKey]: U[c.SexprKey];
}>(value: U extends (Cion.Lisp<`(${T} ${U[c.SexprKey] extends string ? U[c.SexprKey] : never})`> extends LispFalsy ? never : U) ? U : never) => U;
export declare const ro: <U extends unknown[] | Record<PropertyKey, unknown>>(u: U) => ut.DeepReadonly<U>;
export declare const tap1: <S extends {
    [c.SexprKey]: string;
    [c.ContKey]: string;
    [c.ValueKey]: S[c.ValueKey];
}, F extends {
    [c.SexprKey]: string;
    [c.ContKey]: string;
    [c.ValueKey]: {
        [c.PreKey]: string | string[];
        [c.FnKey]: Function;
    };
}, _RetType extends compiler.Ltc<BPost extends string ? BPost : "">, RetType extends (_RetType extends Function ? {
    [c.PreKey]: F[c.ValueKey][c.PreKey][1];
    [c.FnKey]: _RetType;
} : _RetType), BPre extends `(${F[c.ValueKey][c.PreKey] extends string ? F[c.ValueKey][c.PreKey] : F[c.ValueKey][c.PreKey][0]} ${S[c.SexprKey]})`, BCont extends `(${F[c.SexprKey]} ${S[c.SexprKey]})`, BPost extends Cion.Lisp<BCont>>(lf: F, a: S extends (Cion.Lisp<BPre> extends LispFalsy ? never : S) ? S : never) => {
    [c.SexprKey]: BPost;
    [c.ValueKey]: RetType;
};
export type Foxelement = {
    [c.SexprKey]: string;
    [c.ValueKey]: ut.Primitive | unknown[] | Record<PropertyKey, unknown> | Function;
} | Foxfn;
export type Foxfn = {
    [c.SexprKey]: string;
    [c.ValueKey]: {
        [c.PreKey]: string | string[];
        [c.FnKey]: Function;
    };
};
export type GetPre<S extends Foxfn> = S[c.ValueKey][c.PreKey];
export type GetFn<S extends Foxfn> = S[c.SexprKey];
export * as foxp from './foxp.js';