/**
 * Returns number in case `T` is an `Array`,
 * else if `T extends Record<any, any>`, it returns the keys of it,
 * else it returns never.
 */
export type ToKeys<T> = T extends Array<any> ? number : T extends Record<any, any> ? {
    [K in keyof T]: K;
}[keyof T] : never;
/**
 * Return type of the pick function.
 */
export type PickReturn<T, K extends ToKeys<T>> = T extends Array<infer A> ? A | undefined : T extends Record<any, any> ? K extends keyof T ? T[K] | undefined : never : undefined;
/**
 * Takes a value `T` and a key `K`.
 * If value is an `Array<A>` (`K` is enforced as number in this case), it returns `value[key]` as `A | undefined`.
 * If value is a `Record<any, any>` (`K` is enforced as `keyof T` in this case), it returns `value[key]` as `T[K] | undefined`.
 * Else it returns undefined.
 */
export declare const pick: <T, K extends ToKeys<T>>(value: T | undefined, key: K) => PickReturn<T, K>;
/**
 * An `OptionalLens<T, P>` grants type-safe access on potential `P`, hence it can be used to
 * get `P | undefined` from an arbitrary `T`, where `T` might be a union of arbitrary types.
 *
 * From an `OptionalLens<T, P>`, you can also retrieve a new `OptionalLens<P, P[K]>`, where K is a potential key of P.
 * Use `getLens<T>()` to get an initial `OptionalLens<T, T>`.
 *
 * You can see `OptionalLens` as "universal optional chaining". While normal optional chaining only works on a `T | null | undefined`,
 * the `OptionalLens` allows the type-safe access on arbitrary unions.
 *
 * E.g. given the following type and values:
 * ```ts
 * type TestChild = boolean | { x: number | Array<number> };
 * type Test =
 *   | number
 *   | {
 *       a: string | Array<boolean | TestChild>;
 *     };
 *
 *   const t1: Test = 42;
 *   const t2: Test = { a: 'Test3' };
 *   const t3: Test = { a: [true, { x: 7 }, { x: [1, 2, 3] }] };
 *   const t4: TestChild = { x: 7 };
 * ```
 *
 * you could get the following results with optional-lenses:
 * ```ts
 * const lensA = getLens<Test>().k('a');
 * const a1 = lensA.get(t1); // => undefined (inferred as undefined | string | Array<boolean | TestChild>)
 * const a2 = lensA.get(t2); // => 'Test3' (inferred as undefined | string | Array<boolean | TestChild>)
 * const a3 = lensA.get(t3); // => [true, { x: 7 }, { x: [1, 2, 3] }] (inferred as undefined | string | Array<boolean | TestChild>)
 *
 * const lensA2X1 = lensA.k(2).k('x').k(1);
 * const n1 = lensA2X1.get(t1); // => undefined (inferred as number | undefined)
 * const n2 = lensA2X1.get(t2); // => undefined (inferred as number | undefined)
 * const n3 = lensA2X1.get(t3); // => 2 (inferred as number | undefined)
 *
 * const lensB = getLens<Test>().compose(getLens<TestChild>());
 * const t3a = lensB.k('a').get(t3); // [true, { x: 7 }, { x: [1, 2, 3] }] (inferred as undefined | string | Array<boolean | TestChild>)
 * const t4x = lensB.k('x').get(t4); // 7 (inferred as undefined | number | Array<number>)
 * ```
 */
export type OptionalLens<T, P> = {
    get: (value: T) => P | undefined;
    k: <K extends ToKeys<P>>(key: K) => OptionalLens<T, PickReturn<P, K>>;
    compose: <T2, P2>(lens: OptionalLens<T2, P2>) => OptionalLens<T | T2, P | P2>;
};
/**
 * Typeguard to check, if the given value is an {@link OptionalLens}
 */
export declare const isOptionalLens: <T, P>(value: any) => value is OptionalLens<T, P>;
/**
 * Get an `OptionalLens<T, T>` for type-safe access on arbitrarily nested properties of type `T`,
 * where `T` might be a union of arbitrary types.
 *
 * Given the following type and values:
 * ```ts
 * type TestChild = boolean | { x: number | Array<number> };
 * type Test =
 *   | number
 *   | {
 *       a: string | Array<boolean | TestChild>;
 *     };
 *
 *   const t1: Test = 42;
 *   const t2: Test = { a: 'Test3' };
 *   const t3: Test = { a: [true, { x: 7 }, { x: [1, 2, 3] }] };
 *   const t4: TestChild = { x: 7 };
 * ```
 *
 * you could get the following results with optional-lenses:
 * ```ts
 * const lensA = getLens<Test>().k('a');
 * const a1 = lensA.get(t1); // => undefined (inferred as undefined | string | Array<boolean | TestChild>)
 * const a2 = lensA.get(t2); // => 'Test3' (inferred as undefined | string | Array<boolean | TestChild>)
 * const a3 = lensA.get(t3); // => [true, { x: 7 }, { x: [1, 2, 3] }] (inferred as undefined | string | Array<boolean | TestChild>)
 *
 * const lensA2X1 = lensA.k(2).k('x').k(1);
 * const n1 = lensA2X1.get(t1); // => undefined (inferred as number | undefined)
 * const n2 = lensA2X1.get(t2); // => undefined (inferred as number | undefined)
 * const n3 = lensA2X1.get(t3); // => 2 (inferred as number | undefined)
 *
 * const lensB = getLens<Test>().compose(getLens<TestChild>());
 * const t3a = lensB.k('a').get(t3); // [true, { x: 7 }, { x: [1, 2, 3] }] (inferred as undefined | string | Array<boolean | TestChild>)
 * const t4x = lensB.k('x').get(t4); // 7 (inferred as undefined | number | Array<number>)
 * ```
 */
export declare const getLens: <T>() => OptionalLens<T, T>;
/**
 * Get a concrete `OptionalLens<T, P>` from an `OptionalLens<any, any>` (or never, if L is no `OptionalLens<any, any>`)
 */
export type ToLensType<L> = [L] extends [OptionalLens<infer T, infer P>] ? OptionalLens<T, P> : never;
/**
 * Get a concrete `T` from an `OptionalLens<T, any>` (or never, if L is no `OptionalLens<any, any>`)
 */
export type ToLensInputType<L> = [L] extends [OptionalLens<infer T, any>] ? T : never;
/**
 * Get a concrete `T` from an `OptionalLens<any, T>` (or never, if L is no `OptionalLens<any, any>`)
 */
export type ToLensOutputType<L> = [L] extends [OptionalLens<any, infer T>] ? T : never;
/**
 * Get `T`, if `VL` is an `OptionalLens<T, any>`, else get `OptionalLens<VL, any>`
 */
export type ValueOrLens<VL> = [VL] extends [OptionalLens<any, any>] ? ToLensInputType<VL> : OptionalLens<VL, any>;
/**
 * Get return type of `OptionalLens<T, PX>::get(T)`, if `X` is an `OptionalLens<any, any>`,
 * else get the return type of `OptionalLens<T, PY>::get(T)`, if `Y` is an `OptionalLens<any, any>`,
 * else never.
 */
export type FromLensReturn<X, Y> = [X] extends [OptionalLens<any, any>] ? ToLensOutputType<X> | undefined : [Y] extends [OptionalLens<any, any>] ? ToLensOutputType<Y> | undefined : never;
/**
 * Utility function to apply an `OptionalLens<T, P>` to a `T`
 */
export declare const fromValueAndLens: <T>(value: T) => <L extends OptionalLens<T, any>>(lens: L) => ToLensOutputType<L> | undefined;
/**
 * Utility function to apply a `T` to an `OptionalLens<T, P>`
 */
export declare const fromLensAndValue: <L extends OptionalLens<any, any>>(lens: L) => <T extends ToLensInputType<L>>(value: T) => ToLensOutputType<L> | undefined;
/**
 * If the first argument is an `OptionalLens`, this function behaves like `fromLensAndValue`,
 * else it behaves like `fromValueAndLens`
 */
export declare const fromLens: <X>(valueOrLens1: X) => <Y extends ValueOrLens<X>>(valueOrLens2: Y) => FromLensReturn<X, Y>;
/**
 * Return type of the toGetter function.
 * Like {@link OptionalLens}, a `Getter<T>` can be used for optional chaining on arbitrary union types.
 * In contrast to {@link OptionalLens}, the initial `Getter<T>` must be obtained from a value of type `T`.
 * You can thus use it as kind of ad-hoc lens for a one-time access. In most cases however,
 * using an {@link OptionalLens} is the better choice.
 *
 * See `toGetter` documentation for example usage.
 */
export type Getter<T> = {
    get: () => T;
    k: <K extends ToKeys<T>>(key: K) => Getter<PickReturn<T, K>>;
};
/**
 * Helper type to infer the concrete value type `T` wrapped by a `Getter<T>`
 */
export type ToGetterValue<T> = T extends Getter<infer V> ? V : never;
/**
 * Wraps the given value of type T in a `Getter<T>`.
 * A `Getter<T>` can be used like a one-time ad-hoc version of an {@link OptionalLens}.
 * In most cases however, using an {@link OptionalLens} is the better choice.
 *
 * Given the following type and values:
 * ```ts
 * type Test =
 *   | number
 *   | {
 *       x: Array<number>;
 *       a: {
 *         b: number;
 *       };
 *   | {
 *       a: {
 *         b: string;
 *       }
 *     }
 * };
 *
 * let t1: Test = 42;
 * let t2: Test = { x: [1, 2, 3] };
 * let t3: Test = { a: { b: 'Test' } };
 * ```
 *
 * you could get the following results with toGetter:
 * ```ts
 * const b1 = toGetter(t1).k('a').k('b').get(); // => undefined (inferred as number | string | undefined)
 * const b2 = toGetter(t2).k('a').k('b').get(); // => undefined (inferred as number | string | undefined)
 * const b3 = toGetter(t3).k('a').k('b').get(); // => 'Test' (inferred as number | string | undefined)
 * const x1 = toGetter(t1).k('x').k(1).get(); // => undefined (inferred as number | undefined)
 * const x2 = toGetter(t2).k('x').k(1).get(); // => 2 (inferred as number | undefined)
 * const x3 = toGetter(t3).k('x').k(1).get(); // => undefined (inferred as number | undefined)
 * ```
 */
export declare const toGetter: <T>(value: T) => Getter<T>;