export declare function pipe<A>(value: A): A;
export declare function pipe<A, B>(value: A, ab: (input: A) => B): B;
export declare function pipe<A, B, C>(value: A, ab: (input: A) => B, bc: (input: B) => C): C;
export declare function pipe<A, B, C, D>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D): D;
export declare function pipe<A, B, C, D, E>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E): E;
export declare function pipe<A, B, C, D, E, F>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F): F;
export declare function pipe<A, B, C, D, E, F, G>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F, fg: (input: F) => G): G;
export declare function pipe<A, B, C, D, E, F, G, H>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F, fg: (input: F) => G, gh: (input: G) => H): H;
export declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F, fg: (input: F) => G, gh: (input: G) => H, hi: (input: H) => I): I;
export declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F, fg: (input: F) => G, gh: (input: G) => H, hi: (input: H) => I, ij: (input: I) => J): J;
/**
 * The same composition, without a value - a reusable function.
 *
 * `pipe` transforms something now; this builds the transformation to apply
 * later, which is what makes it usable as a callback:
 *
 * ```ts
 * const normalize = piped(
 *   (name: string) => name.trim(),
 *   name => name.toLowerCase(),
 * )
 *
 * names.map(normalize)
 * ```
 *
 * The first step's parameter type is what the resulting function accepts, so it
 * has to be annotated - there is nothing else for inference to work from.
 */
export declare function piped<A, B>(ab: (input: A) => B): (input: A) => B;
export declare function piped<A, B, C>(ab: (input: A) => B, bc: (input: B) => C): (input: A) => C;
export declare function piped<A, B, C, D>(ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D): (input: A) => D;
export declare function piped<A, B, C, D, E>(ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E): (input: A) => E;
export declare function piped<A, B, C, D, E, F>(ab: (input: A) => B, bc: (input: B) => C, cd: (input: C) => D, de: (input: D) => E, ef: (input: E) => F): (input: A) => F;
/**
 * Run a side effect on a value and hand the value back.
 *
 * For inspecting a pipeline without breaking it - the step that logs, or
 * records a metric, and does not change what flows on:
 *
 * ```ts
 * pipe(
 *   users,
 *   list => sortBy(list, u => u.score),
 *   tap(list => log.debug(`${list.length} users`)),
 *   list => take(list, 3),
 * )
 * ```
 *
 * The effect's return value is discarded on purpose. A step that means to
 * change the value should be an ordinary step, where the type says so.
 */
export declare function tap<T>(effect: (value: T) => unknown): (value: T) => T;