carmi/typings/index.d.ts

export interface FunctionLibrary { [name: string]: (...args: any[]) => any }
interface Looper<T> { }

type UnionToIntersection<U> = (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never

interface AbstractGraph {$isCarmiGraph: true}
export interface GraphBase<NativeType> extends AbstractGraph {$value: NativeType}

export type AsNative<T> = T extends GraphBase<infer N> ? N : T
export type Argument<T> = AsNative<T> | GraphBase<T> | T
type MatchesArguments<Function, Args extends any[]> = Function extends (...args: Args) => any ? true : false
type AsNativeRecursive<T> =
        AsNative<T> extends any[] ? AsNative<T> :
        AsNative<T> extends object ? {[k in keyof AsNative<T>]: AsNative<AsNative<T>[k]>} : AsNative<T>
type BoundFunction<F, A = unknown, B = unknown, C = unknown, D = unknown, E = unknown> =
    unknown extends A ? (F extends (...args: infer Args) => infer R ? F : never) :
    unknown extends B ? (F extends (a: A, ...args: infer Args) => infer R ? (...args: Args) => R : never) :
    unknown extends C ? (F extends (a: A, b: B, ...args: infer Args) => infer R ? (...args: Args) => R : never) :
    unknown extends D ? (F extends (a: A, b: B, c: C, ...args: infer Args) => infer R ? (...args: Args) => R : never) :
    unknown extends E ? (F extends (a: A, b: B, c: C, d: D, ...args: infer Args) => infer R ? (...args: Args) => R : never) :
    never

export interface BoolGraph<F extends FunctionLibrary> extends GraphImpl<boolean, F> {}
export interface FunctionGraph<N, F extends FunctionLibrary> extends GraphImpl<N, F> {}

/**
* Graph
*/
interface GraphImpl<NativeType, F extends FunctionLibrary> extends GraphBase<NativeType> {
    /**
     * Returns a graph that resolves to the return type of a named function from the function library.
     *
     * @param func A function name from the function library
     * @param args Args to pass, in addition to the value resolved from ""
     */
    call<FunctionName extends keyof F, Arguments extends (F[FunctionName] extends (firstArg: NativeType, ...args: infer Args) => any ? Args : never)>(func: FunctionName, ...args: Arguments extends (infer A)[] ? Argument<A>[] : never):
        Graph<ReturnType<F[FunctionName]>, F>
    /**
    * Like call but will exectue even if the parameters mutation resulted in the same values.
    * **Please note**: `effect(func, args)` is a leaf and ends the chain, and its return value cannot be used.
    */
    effect<FunctionName extends keyof F, Arguments extends (F[FunctionName] extends (firstArg: NativeType, ...args: infer Args) => any ? Args : never)>(func: FunctionName, ...args: Arguments extends (infer A)[] ? Argument<A>[] : never): void

    /**
    * Creates a function that invokes functionName from the function library with args prepended to the arguments it receives.
    */
    bind<FunctionName extends keyof F>(func: FunctionName): FunctionGraph<BoundFunction<F[FunctionName], NativeType>, F>
    bind<FunctionName extends keyof F, A>(func: FunctionName, a: A): FunctionGraph<BoundFunction<F[FunctionName], NativeType, A>, F>
    bind<FunctionName extends keyof F, A, B>(func: FunctionName, a: A, b: B): FunctionGraph<BoundFunction<F[FunctionName], NativeType, A, B>, F>
    bind<FunctionName extends keyof F, A, B, C>(func: FunctionName, a: A, b: B, c: C): FunctionGraph<BoundFunction<F[FunctionName], NativeType, A, B, C>, F>
    bind<FunctionName extends keyof F, A, B, C, D>(func: FunctionName, a: A, b: B, c: C, d: D): FunctionGraph<BoundFunction<F[FunctionName], NativeType, A, B, C, D>, F>

    /**
     * Generates a breakpoint (debugger clause), continuing the graph.
     */
    breakpoint(): this

    /**
     * Generates a console statement, continuing the chain.
     * @param label if provided, label is printed alongside the trace info
     */
    trace(label?: string): this

    /**
     * Generates a console statement, continuing the chain if condition resolves to true.
     * @param condition
     * @sugar */
    conditionalTrace<FunctionName extends keyof F>(condition: FunctionName): this

    /**
     * Triggers a breakpoint if the condition resolves to true.
     * @param condition
     * @sugar */
    conditionalBreakpoint<FunctionName extends keyof F>(condition: FunctionName): this

    /**
     * Lets you tap into the value and traces the result of tapFn.
     * @param tapFn
     * @sugar */
    tapTrace<FunctionName extends keyof F>(tapFn: FunctionName): this


    /**
     * Resolves to `!NativeType`.
     */
    not(): BoolGraph<F>

    /**
     * Resolves to either consequence or alternate, based on the value of NativeType.
     * Note that both options will be evaluated, even if one of them is not semantically possible.
     *
     * @param consequence graph if NativeType value is truthy
     * @param alternate graph is NativeType value is falsey
     */
    ternary<Consequence, Alternate>(consequence: Consequence, alternate: Alternate):
                    Graph<
                    AsNative<Consequence> extends AsNative<Alternate> ? Consequence :
                    AsNative<Alternate> extends AsNative<Consequence> ? Alternate :
                    Consequence extends null ? Alternate :
                    Alternate extends null ? Consequence :
                    Alternate | Consequence, F>

    /**
     * Resolves to the case that matches equals to the boxed value.
     *
     * @param caseTuples An array of pairs between a value and a consequent
     * @param defaultCase The graph to return in case no given case matches the boxed value
     * @sugar */
    switch<DefaultCase, TupleType extends [Argument<NativeType>, any]>(caseTuples: Array<TupleType>, defaultCase: DefaultCase):
        Graph<DefaultCase, F> |
        Graph<TupleType extends [Argument<NativeType>, infer Result] ? Result : never, F>

    /**
     * Returns a boolean graph that resolves to the value of (NativeType === other).
     * @param other
     */
    eq(other: Argument<unknown>): BoolGraph<F>

    /**
     * When run on a key inside a recursiveMap/recursiveMapValues functor,
     * will return the resolved value for a given key. NativeType allows returning values for indicies of a map based on other values.
     * @param loop passed to the functor of recursiveMap/recursiveMapValues
     */
    recur<ValueType>(loop: Looper<ValueType>): ValueType

    /**
    * Returns true if the context is of type `Array`.
    */
    isArray(): BoolGraph<F>

    /**
    * Returns true if the context is `undefined`.
    */
    isUndefined(): BoolGraph<F>

    /**
    * Returns true if the context is of type `boolean`.
    */
    isBoolean(): BoolGraph<F>

    /**
    * Returns true if the context is of type `number`.
    */
    isNumber(): BoolGraph<F>

    /**
    * Returns true if the context is of type `string`.
    */
    isString(): BoolGraph<F>
}

/**
* Number
*/
export interface NumberGraph<NativeType extends number, F extends FunctionLibrary> extends GraphImpl<NativeType, F> {
    /**
     * Resolves to (NativeType > other).
     * @param other
     */
    gt(other: Argument<number>): BoolGraph<F>

    /**
     * Resolves to (NativeType >= other).
     * @param other
     */
    gte(other: Argument<number>): BoolGraph<F>

   /**
     * Resolves to (NativeType < other).
     * @param other
     */
    lt(other: Argument<number>): BoolGraph<F>

   /**
     * Resolves to (NativeType <= other).
     * @param other
     */
    lte(other: Argument<number>): BoolGraph<F>

   /**
     * Resolves to (NativeType - other).
     * @param other
     */
    minus(value: Argument<number>): NumberGraph<number, F>

   /**
     * Resolves to (NativeType * other).
     * @param other
     * @example
     * const { root } = require('carmi')
     * const instance = createInstance({
     *     output: root.mult(2)
     * }, 2)
     * instance.output //4
     */
    mult(value: Argument<number>): NumberGraph<number, F>

   /**
     * Resolves to (NativeType + other).
     * @param other
     */
    plus(num: Argument<number>): NumberGraph<number, F>
    plus(str: Argument<string>): StringGraph<string, F>

   /**
     * Resolves to (NativeType / other).
     * @param other
     */
    div(value: Argument<number>): NumberGraph<number, F>

   /**
     * Resolves to (NativeType % other).
     * @param other
     */
    mod(value: Argument<number>): NumberGraph<number, F>

    /**
     * Creates a number array graph.
     *
     * @param start number to start from
     * @param skip number to skip between values
     * @returns a number array graph, with size equal to resolved "NativeType"
     */
    range(start?: Argument<number>, skip?: Argument<number>): NumberGraph<number, F>[]

    /**
     * Resolves to Math.floor(NativeType).
     */
    floor(): NumberGraph<number, F>

    /**
     * Resolves to Math.ceil(NativeType).
     */
    ceil(): NumberGraph<number, F>

    /**
     * Resolves to Math.round(NativeType).
     */
    round(): NumberGraph<number, F>
}

/**
* String
*/
interface StringGraph<NativeType extends string, F extends FunctionLibrary> extends GraphImpl<NativeType, F> {
    /**
     * Resolves to (NativeType.startsWith(s)).
     * @param s other string
     */
    startsWith(s: Argument<string>): BoolGraph<F>

    /**
     * Resolves to (NativeType.endsWith(s)).
     * @param s other string
     */
    endsWith(s: Argument<string>): BoolGraph<F>

    /**
     * Resolves to (NativeType + s).
     * @param other other string
     */
    plus(other: Argument<string|number>): StringGraph<string, F>

    /**
     * Resolves to an array graph, like NativeType.split(separator).
     * @param separator
     */
    split(separator: Argument<string>): ArrayGraph<string[], F>

    /**
     * Resolves to NativeType.toUpperCase().
     */
    toUpperCase(): StringGraph<string, F>

    /**
     * Resolves to NativeType.toLowerCase().
     */
    toLowerCase(): StringGraph<string, F>

    /**
     * Returns the string length.
     */
    stringLength(): NumberGraph<number, F>

    /**
     * Resolves `String.substring`.
     * @param start
     * @param end
     *
     * Resolves String.substring
     */
    substring(start: Argument<number>, end: Argument<number>): StringGraph<string, F>



    /**
     * Resolves to parseInt(NativeType, radix).
     * @param radix base (10, 16 etc)
     */
    parseInt(radix?: number): NumberGraph<number, F>
}

/**
* Array or Object
*/
interface ArrayOrObjectGraphImpl<NativeType extends any[]|object, F extends FunctionLibrary, Key = keyof NativeType>
    extends GraphImpl<NativeType, F> {
    /**
    * Returns the specific key/index from the object/array.
    */
    get<K extends keyof NativeType>(key: K|AbstractGraph): K extends AbstractGraph ? Graph<NativeType[keyof NativeType], F> : Graph<NativeType[K], F>

    /**
     * Checks if the object or array graph is empty.
     @sugar */
    isEmpty(): BoolGraph<F>

    /**
     * Resolves to the deep value provided by the path.
     * @param path
     * @sugar */
    getIn<K extends keyof NativeType>(path: [Argument<K>]): Graph<NativeType[K], F>
    getIn<K0 extends keyof NativeType, K1 extends keyof NativeType[K0]>(path: [Argument<K0>, Argument<K1>]): Graph<NativeType[K0][K1], F>
    getIn<K0 extends keyof NativeType, K1 extends keyof NativeType[K0], K2 extends keyof NativeType[K0][K1]>(path: [Argument<K0>, Argument<K1>, Argument<K2>]): Graph<NativeType[K0][K1][K2], F>
    getIn<K0 extends keyof NativeType, K1 extends keyof NativeType[K0], K2 extends keyof NativeType[K0][K1], K3 extends keyof NativeType[K0][K1][K2]>(path: [Argument<K0>, Argument<K1>, Argument<K2>, Argument<K3>]):
        Graph<NativeType[K0][K1][K2][K3], F>
    getIn<K0 extends keyof NativeType, K1 extends keyof NativeType[K0], K2 extends keyof NativeType[K0][K1], K3 extends keyof NativeType[K0][K1][K2], K4 extends keyof NativeType[K0][K1][K2][K3]>(path: [Argument<K0>, Argument<K1>, Argument<K2>, Argument<K3>, Argument<K4>]):
        Graph<NativeType[K0][K1][K2][K3][K4], F>
    /**
    * Returns true if the key/index exists on the object/array.
    */
    has(key: Argument<string> | Argument<number>): BoolGraph<F>
}

/**
* Array
*/
interface ArrayGraphImpl<NativeType extends any[], F extends FunctionLibrary,
    Value = NativeType extends (infer V)[] ? AsNative<V> : never,
    Key = keyof NativeType,
    ValueGraph = Graph<Value, F>,
    KeyGraph = NumberGraph<number, F>> extends ArrayOrObjectGraphImpl<Value[], F> {

    /**
     * Resolves to NativeType.length
     */
    size(): NumberGraph<NativeType['length'], F>

    /**
     * Combines all array values of the object. Like: `_.reduce(NativeType, _.assign, {})`
     */
    // @ts-ignore
    assign<T = NativeType extends object ? true : never>(): ObjectGraph<UnionToIntersection<Value>, F>

    /**
     * Combines all array values of the object, in reverse order. Like: `_.reduce(NativeType, _.defaults, {})`
     */
    // @ts-ignore
    defaults<T = NativeType extends object ? true : never>(): ObjectGraph<UnionToIntersection<Value>, F>

    /**
     * Resolves to the first item in an array.
     * @sugar */
    head(): ValueGraph

    /**
     * Resolves to the last item in an array.
     * @sugar */
    last(): ValueGraph

    /**
     * Resolves to the sum of numbers in a number array.
     *
     */
    sum(): Value extends number ? NumberGraph<number, F> : never

    /**
     * Reverses the order of a given array.
     * @sugar */
    reverse(): ArrayGraph<Value[], F>

    /**
     * Runs the functor for every item in an array. Returns a graph that resolves to an array with the returned values.
     *
     * @param functor A function to run for every item of the array
     * @param scope A variable to pass to the functor if inside another functor.
     * @example
     * const { root } = require('carmi')
     * const instance = createInstance({
     *     output: root.map( item => item.mult(2))
     * }, [3, 2, 1])
     * instance.output //[6, 4, 2]
     */
    map<Scope, Ret>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<Ret>, scope?: Scope) : ArrayGraph<Ret[], F>

    /**
     * Returns a boolean graph that resolves to *true* if at least one element in the array
     * passes the test implemented by the provided functor.
     *
     * @param functor A function to run for every item of the array, returning boolean
     * @param scope A variable to pass to the functor if inside another functor.
     * @example
     * const { root } = require('carmi')
     * const instance = createInstance({
     *     output: root.any((value, index) => value.eq(2))
     * }, [3, 2, 1])
     * instance.output //true
     */
    any<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<boolean>, scope?: Scope) : BoolGraph<F>

    /**
     * Returns a boolean graph that resolves to true if running the functor on all of the array's items resolved to true.
     *
     * @param functor A function to run for every item of the array, returning boolean
     * @param scope A variable to pass to the functor if inside another functor.
     * @sugar */
    every<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<boolean>, scope?: Scope) : BoolGraph<F>

    /**
     * Returns an object graph that resolves to an object containing keys returned by functor, pointing to their first found corresponding value.
     *
     * @param functor A function to run for every item of the array, returning a string as a new key
     * @param scope A variable to pass to the functor if inside another functor.
     * @example
     * const { root, chain } = require('carmi');
     * const instance = createInstance({
     *   output: root
     *     .keyBy(item => item.get('items').size())
     *     .mapValues(item => item.get('items'))
     * }, [{items: [1]}, {items: [1, 2]}, {items: [1, 2, 3]}, {items: [1, 2, 3, 4]}]);
     * instance.output // {1: [1], 2: [1, 2], 3: [1, 2, 3], 4: [1, 2, 3, 4]}
     **/
    keyBy<Scope, Ret extends Argument<string>>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<Ret>, scope?: Scope) :
        ObjectGraph<Ret extends string ? {[name in Ret]: Value} : {[name: string]: Value}, F>

    /**
     * Returns an array graph containing only the values for which the functor resolved to `true`.
     *
     * @param functor A function to run for every item of the array, returning a boolean
     * @param scope A variable to pass to the functor if inside another functor.
     * @example
     * const { root } = require('carmi')
     * const instance = createInstance({
     *     output: root.filter( item => item.mod(2))
     * }, [3, 2, 1])
     * instance.output //[3, 1]
     */
    filter<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => any, scope?: Scope) : ArrayGraph<Value[], F>

    /**
     * Resolved to the index of the first value for which the functor resolved to true, or -1 if not found.
     *
     * @param functor A function to run for every item of the array, returning a boolean
     * @param scope A variable to pass to the functor if inside another functor.
     * @sugar */
    findIndex<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<boolean>, scope?: Scope) : KeyGraph

    /**
     * Returns a value that is a result of running functor on all the items of the array in order, each time with the previous result of functor.
     *
     * @param functor A function to run for every item of the array, with the previous value as aggregate
     * @param initialValue The aggregate to pass to the first argument.
     * @sugar */
    reduce<Ret>(functor: (aggregate: Argument<Ret>, value?: ValueGraph, key?: KeyGraph) => Argument<Ret>, initialValue?: Ret): NativeType extends any[] ? Ret : never

    /**
     * Resolves to an array which is a concatenated results of NativeType and one or more additional arrays.
     * @param arrays
     * @sugar */
    concat<T>(...arrays: Argument<T[]>[]) : ArrayGraph<(Value|T)[], F>

    /**
     * Resolves to an array of unique values that are included in given arrays of strings.
     * @param arrays
     * @sugar */
    intersection<T>(...arrays: Argument<T[]>[]) : ArrayGraph<(Value|T)[], F>

    /**
     * Resolves to the first value for which the functor resolves to `true`.
     *
     * @param functor A function to run for every item of the array, returning a boolean
     * @param scope A variable to pass to the functor if inside another functor.
     * @sugar */
    find<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<boolean>, scope?: Scope) : ValueGraph

    /**
     * Joins an array of strings to a single string, like `NativeType.join(separator)`.
     * @param separator
     * @sugar */
    join(separator: Argument<string>): Value extends string ? StringGraph<string, F> : never

    /**
     * Returns an array graph with an additional element (value) at the end.
     *
     * @param value A value to add to the array, or a graph resolving to that value
     * @sugar */
    append<T>(value: Argument<T>) : ArrayGraph<(Value|T)[], F>

    /**
     * Flattens inner arrays into an array.
     */
    flatten<T = Value extends any[] ? true : never>() : ValueGraph

    /**
     * Resolves to true if the array contains an argument equal to value.
     * @param value
     * @sugar */
    includes(value: Argument<Value>): BoolGraph<F>

    /**
    * Resolves to the same array, with only `true` values
    * @sugar */
    compact(): this

    /**
     * Resolves to a duplicate-free version of an array of strings.
     * @sugar */
    uniq(): this

    /**
    * Resolves to an array with size identical to NativeType, with each element resolving to the result of functor on the equivalent element in NativeType.
    * The functor is given a "loop" parameter, which can be used to retrieve the functor's result on a different key. For example:
    *
    * // Will resolve to [1, 2, 4, 8, ...]
    * recursiveMap((loop, value, key) => key.eq(0).ternary(1, key.minus(1).recur(loop).multiply(2)))
    *
    * @param functor
    * @param scope
    */
    recursiveMap<Scope, Ret>(functor: (loop: Looper<Ret>, value?: Value, key?: Key, scope?: Scope) => Argument<Ret>, scope?: Scope): ArrayGraph<Ret[], F>
}

/**
* Object
*/
interface ObjectGraphImpl<NativeType extends {[key: string]: any}, F extends FunctionLibrary,
    Key = keyof NativeType,
    Value = AsNative<NativeType[keyof NativeType]>,
    ValueGraph = Graph<Value, F>,
    KeyGraph = Graph<keyof NativeType, F>> extends ArrayOrObjectGraphImpl<{[key in keyof NativeType]: AsNative<NativeType[key]>}, F> {

    /**
     * Resolves to the number of keys in the object
     */
    size(): NumberGraph<number, F>

    /**
     * Resolves to true if NativeType has the given key as a key
     * @param key A potential key of NativeType
     */
    has(key: Argument<string>): BoolGraph<F>

    /**
     * Resolves to true if NativeType object has a value equal to the value argument.
     *
     * @param value
     * @sugar */
    includesValue(value: Argument<Value>): BoolGraph<F>

    /**
     * Resolves to a new object with the entries for which the functor has resolved to true.
     *
     * @param functor
     * @param scope
     */
    filterBy<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => any, scope?: Scope) : this

    /**
     * Resolves to a new object with only the keys passed as argument
     *
     * @param functor
     * @param scope
     * @sugar */
    pick<K extends keyof NativeType>(keys: Argument<K[]>): this

    /**
     * Resolves to an object with the same keys, with each value resolves to the return value of functor on the corresponding entry.
     *
     * @param functor
     * @param scope
     */
    mapValues<Scope, Ret>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Ret, scope?: Scope) :
        ObjectGraph<{[name in keyof NativeType]: AsNativeRecursive<Ret>}, F>

    /**
     * Resolves to an object with the same values, with each key resolves to the return value of functor on the corresponding entry.
     *
     * @param functor
     * @param scope
     */
    mapKeys<Scope, Ret>(functor: (value: ValueGraph, key?: StringGraph<string, F>, scope?: Scope) => Ret, scope?: Scope) : ObjectGraph<{[key in Ret extends string ? Ret : string]: Value}, F>
    mapKeys(key: Argument<string>) : ObjectGraph<{[key: string]: Value}, F>

    /**
     * Resolves to a boolean representing whether the object contains any value for which the functor has resolved to true
     *
     * @param functor
     * @param scope
     */
    anyValues<Scope>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<boolean>, scope?: Scope) : BoolGraph<F>

    /**
     * Returns a new object with the keys returned by the functor, and the values resolves to arrays with all the elements which returned that key.
     */
    groupBy<Scope, Ret>(functor: (value: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<Ret>, scope?: Scope) : ObjectGraph<{[key: string]: NativeType}, F>

    /**
     * Returns a new object which resolves to `_.assign(NativeType, value)`.
     *
     * @param value
     * @sugar */
    assignIn<V extends object>(value: Argument<V>[]): ObjectGraph<NativeType & AsNative<V>, F>

    /**
    * Sets value for given key.
    *
    * @param key string
    * @param value
    * @sugar */
    simpleSet(path: string): ObjectGraph<NativeType, F>

    /**
    * Sets value for given path.
    *
    * @param path[] Array
    * @param value
    * @sugar */
    setIn(path: string[]): ObjectGraph<NativeType, F>

    /**
     * Resolves to an object with keys identical to NativeType, with each element resolving to the result of functor on the equivalent element in NativeType.
     * The functor is given a "loop" parameter, which can be used to retrieve the functor's result on a different key. For example:
     *
     * @param functor
     * @param scope
     */
    recursiveMapValues<Scope, Ret>(functor: (loop: Looper<Ret>, value?: ValueGraph, key?: KeyGraph, scope?: Scope) => Argument<Ret>, scope?: Scope): ObjectGraph<{
        Key: Ret
    }, F>

    /**
    * Resolves to an array representing the keys of the object.
    *
    */
    keys(): ArrayGraph<Key[], F>

    /**
    * Resolves to an array representing the values of the object.
    *
    */
    values(): ArrayGraph<Value[], F>
}

interface Expression { }
export interface Token { $type: string }
type PathSegment = Token | string | number
type SetterExpression<Model, Path, F> = {}
type SpliceExpression<Model, Path, F> = {}
type PushExpression<Model, Path, F> = {}

export interface ArrayGraph<T extends any[], F extends FunctionLibrary> extends ArrayGraphImpl<T, F> {}
export interface ObjectGraph<T extends object, F extends FunctionLibrary> extends ObjectGraphImpl<AsNative<T>, F> {}

export type Graph<N, F extends FunctionLibrary> =
    N extends AbstractGraph ? N :
    N extends any[] ? ArrayGraph<N, F> :
    N extends Function ? FunctionGraph<N, F> :
    N extends string ? StringGraph<N, F> :
    N extends number ? NumberGraph<N, F> :
    N extends boolean ? BoolGraph<F> :
    N extends object ? ObjectGraph<N, F> :
    never

/**
* External
*/
export interface CarmiAPI<Schema extends object = any, F extends FunctionLibrary = any> {
    $schema: Schema
    $functions: F
    root: ObjectGraphImpl<Schema, F>

    /**
    * Wraps a native JS object with the declarative APIs.
    *
    * @example
    *  const { root, chain } = require('carmi');
    *  const instance = createInstance({
    *    output: chain([{
    *      shelf: root.get(0).get('shelf'),
    *      books: [ root.get(1).get(root.get(0).get('shelf')).get(0) ]
    *   }])
    *   .assign()
    *  }, [{shelf: 'scifi'}, {scifi: ['a scanner darkly']}]);
    *  instance.output //{books: ["a scanner darkly"], shelf: "scifi"}
    */
    chain<T>(t: T): Graph<T, F>

    /**
    * Logical operand or.
    */
    or<A, B>(a: A, b: B): Graph<A, F> | Graph<B, F>
    or<A, B, C>(a: A, b: B, c: C): Graph<A, F> | Graph<B, F> | Graph<C, F>
    or<A, B, C, D>(a: A, b: B, c: C, d: D): Graph<A, F> | Graph<B, F> | Graph<C, F> | Graph<D, F>
    or<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): Graph<A, F> | Graph<B, F> | Graph<C, F> | Graph<D, F> | Graph<E, F>
    or<A, B, C, D, E, FF>(a: A, b: B, c: C, d: D, e: E, f: FF): Graph<A, F> | Graph<B, F> | Graph<C, F> | Graph<D, F> | Graph<E, F> | Graph<FF, F>

    /**
    * Logical operand and.
    */
    and<A>(a: A): Graph<A, F>
    and<A, B>(a: A, b: B): Graph<B, F>
    and<A, B, C>(a: A, b: B, c: C): Graph<C, F>
    and<A, B, C, D>(a: A, b: B, c: C, d: D): Graph<D, F>
    and<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): Graph<E, F>
    and<A, B, C, D, E, FF>(a: A, b: B, c: C, d: D, e: E, f: FF): Graph<FF, F>
    /**
    * Declare actions which can be triggered on your state to change it (use arg0/arg1/arg2 - to define placeholders in the path).
    * @example
    * const { root, setter, arg0 } = require('carmi')
    * const instance = createInstance({
    *     setItem: setter(arg0),
    *     output: root.any((value, index) => value.eq(2))
    * }, [3, 2, 1]);
    * console.log(instance.output) //true
    * instance.setItem(1, 3)
    * instance.output //false
    */
    setter<Path extends PathSegment[]>(...path: Path): SetterExpression<Schema, Path, F>

    /**
    * Declare actions which can be triggered on your state to change it (use arg0/arg1/arg2 - to define placeholders in the path).
    */
    splice<Path extends PathSegment[]>(...path: Path): SpliceExpression<Schema, Path, F>

    /**
    * Declare a setter that adds an element to the end of an array. The setter will create the array if one doesn't exist.
    */
    push<Path extends PathSegment[]>(...path: Path): PushExpression<Schema, Path, F>

    /**
    * Calls the function name passed from the function library while passing current value as the first argument, and then the provided args.
    */
    call<FunctionName extends keyof F, Arguments extends F[FunctionName] extends (...args: (infer Args)[]) => any ? Args : never>(func: FunctionName, ...args: Arguments[]): Graph<ReturnType<F[FunctionName]>, F>

    /**
    * See the docs for [`effect(func, args)`](api.html#effectfunc-args-1) in the **Graph** section of this API reference.
    */
    effect<FunctionName extends keyof F, Args>(func: FunctionName, ...args: Args[]): Graph<ReturnType<F[FunctionName]>, F>

    /**
    * Creates a function that invokes `functionName` from the function library with args prepended to the arguments it receives.
    */
    bind<FunctionName extends keyof F>(func: FunctionName): FunctionGraph<BoundFunction<F[FunctionName]>, F>
    bind<FunctionName extends keyof F, A>(func: FunctionName, a: A): FunctionGraph<BoundFunction<F[FunctionName], A>, F>
    bind<FunctionName extends keyof F, A, B>(func: FunctionName, a: A, b: B): FunctionGraph<BoundFunction<F[FunctionName], A, B>, F>
    bind<FunctionName extends keyof F, A, B, C>(func: FunctionName, a: A, b: B, c: C): FunctionGraph<BoundFunction<F[FunctionName], A, B, C>, F>
    bind<FunctionName extends keyof F, A, B, C, D>(func: FunctionName, a: A, b: B, c: C, d: D): FunctionGraph<BoundFunction<F[FunctionName], A, B, C, D>, F>
    bind<FunctionName extends keyof F, A, B, C, D, E>(func: FunctionName, a: A, b: B, c: C, d: D, e: E): FunctionGraph<BoundFunction<F[FunctionName], A, B, C, D, E>, F>

    /**
    * Defines a projection to be implemented later in the code using the [`implement(iface, name)`](api.html#implementiface-name) method.
    * @param name used for debug only
    */
    abstract(name: string): Graph<unknown, F>

    /**
    * Uses a previously declared abstract clause and assigns an actual value to the named abstract.
    */
    implement(iface: Graph<unknown, F>, name: string): void

    /**
    * A debug feature that allows to name the actual projection functions on the carmi root.
    */
    withName<T>(name: string, g: T): T

    /**
    * This api creates a string using carmi models and the template string method.
    * @example
    * const { root, template } = require('carmi');
    * const instance = createInstance({
    *   output: template`Second array item is:${root.get(1)}.`
    * }, [3, 2, 1]);
    * instance.output //Second array item is:2.
    */
    template<Schema extends object = any, F extends FunctionLibrary = {}>(template: TemplateStringsArray, ...placeholders: any[]): StringGraph<string, F>

    arg0: Token
    arg1: Token
    arg2: Token
}

export const bind: CarmiAPI['bind']
export const or: CarmiAPI['or']
export const and: CarmiAPI['and']
export const setter: CarmiAPI['setter']
export const splice: CarmiAPI['splice']
export const push: CarmiAPI['push']
export const abstract: CarmiAPI['abstract']
export const implement: CarmiAPI['implement']
export const effect: CarmiAPI['effect']
export const call: CarmiAPI['call']
export const chain: CarmiAPI['chain']
export const root: CarmiAPI['root']
export const template: CarmiAPI['template']

declare const carmiDefaultAPI : CarmiAPI
export default carmiDefaultAPI

export function withSchema<Schema extends object, F extends FunctionLibrary = {}>(model?: Schema, functions?: F): CarmiAPI<Schema, F>
export function compile(transformations: object, options ?: object): string