json-expression-eval/dist/types/utils.d.ts

json serializable rule engine / boolean expression evaluator

export type Primitive = boolean | string | number | bigint | symbol | undefined | null;
export type BuiltIn = Function | Error | Date | RegExp | Generator | {
    readonly [Symbol.toStringTag]: string;
};
export type List<T = any> = readonly T[];
export type Cast<A1, A2> = A1 extends A2 ? A1 : A2;
export type Keys<A> = A extends readonly any[] ? Exclude<keyof A, keyof any[]> | number : keyof A;
export type Compute<A> = A extends Function ? A : {
    [K in keyof A]: A[K];
};
export type Split<S extends string, D extends string> = S extends `${infer Head}${D}${infer Tail}` ? [Head, ...Split<Tail, D>] : [S];
export type Join<T extends readonly string[], D extends string> = T extends [] ? '' : T extends [infer Only extends string] ? Only : T extends [infer First extends string, ...infer Rest extends string[]] ? `${First}${D}${Join<Rest, D>}` : string;
type At<A, K extends PropertyKey> = A extends readonly any[] ? number extends A['length'] ? K extends number | `${number}` ? A[number] | undefined : undefined : K extends keyof A ? A[K] : undefined : unknown extends A ? unknown : K extends keyof A ? A[K] : undefined;
type _Path<O, P extends readonly PropertyKey[]> = P extends [] ? O : P extends [infer Head extends PropertyKey, ...infer Tail extends PropertyKey[]] ? _Path<At<O, Head>, Tail> : never;
export type Path<O, P extends readonly PropertyKey[]> = _Path<O, P> extends infer X ? X : never;
export type FilterNever<T extends object> = {
    [K in keyof T as T[K] extends never ? never : K]: T[K];
};
type _Pick<O extends object, K extends PropertyKey> = {
    [P in keyof O & K]: O[P];
};
type _Omit<O extends object, K extends PropertyKey> = _Pick<O, Exclude<keyof O, K>>;
type OptionalFlat<O> = {
    [K in keyof O]?: O[K];
};
type __Either<O extends object, K extends PropertyKey> = _Omit<O, K> & {
    [P in K]: _Pick<O, P>;
}[K];
type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<Record<Exclude<_U extends unknown ? keyof _U : never, keyof U>, never>> : never;
type EitherStrict<O extends object, K extends PropertyKey> = Compute<_Strict<__Either<O, K>>>;
export type RequireOnlyOne<T extends object, K extends keyof T = keyof T> = T extends unknown ? EitherStrict<T, K> : never;
export {};