Added types

lib/functional.d.ts

@@ -0,0 +1,48 @@
+
+type Combinations<A extends Array<any>, Acc extends Array<any> = []> =
+  A extends [a: infer A, ...rest: infer Rest]
+  ? [[...Acc, A], ...Combinations<Rest, [...Acc, A]>]
+  : []
+
+type Curried<T extends (...args: any) => any, LeftArgs extends Array<any> = [Parameters<T>[0]]> =
+  T extends (...args: LeftArgs) => any
+  ? T
+  : T extends (...args: [...LeftArgs, ...infer V]) => infer R
+    ? (...args: LeftArgs) => Curried<(...args: V) => R, LeftArgs>
+    : T extends (a: infer A) => infer R
+      ? (arg_last: A) => R
+      : T extends (a: infer A, ...rest: infer V) => infer R
+        ? ((arg_inner: A) => Curried<(...args: V) => R, LeftArgs>)
+        : never
+
+type CurriedVariants<
+    T extends (...args: any) => any,
+    C extends any[][] = Combinations<Parameters<T>>
+> = T extends () => any
+    ? [T]
+    : { [Cn in keyof C]: Curried<T, Extract<C[Cn], C[number]>>};
+
+type Named<QueryKey extends string, Value> = {
+  [key in QueryKey]: Value;
+}
+
+type NamedCurriedVariants<Name extends string, T extends (...args: any) => any, V = CurriedVariants<T>> =
+  { [C in keyof V]: C extends `${number}` ? Named<Name, V[C]> : never };
+
+type UnionToIntersection<U> = 
+  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
+
+type InterfaceValues<T> = T extends Record<any, infer Inner> ? Inner : never;
+
+type ToFunctional<Func, ExtraArg> = Func extends (...a: infer U) => infer R ? (...a: [...U, ExtraArg]) => R: never;
+
+type Functions = {
+  [x: string]: (...args: any) => any
+};
+
+export type Typify<T> = { [ K in keyof T ]: T[K] };
+
+export type Functionalify<T extends Typify<Functions>, ExtraArg> =
+  UnionToIntersection<InterfaceValues<{
+    [K in keyof T]: UnionToIntersection<NamedCurriedVariants<Extract<K, string>, ToFunctional<T[K], ExtraArg>>[number]>
+}>>