import type { DeepPath, Fn, Maybe, OptPathVal, Path, Path0, Path1, Path2, Path3, Path4, Path5, Path6, Path7, Path8 } from "@thi.ng/api";
/**
 * Non-typechecked version of {@link defGetter}.
 *
 * @remarks
 * The type parameter `T` can be used to indicate the type of the nested value
 * to be retrieved (default: `any`).
 *
 * Also see: {@link getIn}, {@link getInUnsafe}
 *
 * @example
 * ```ts tangle:../export/def-getter-unsafe.ts
 * import { defGetterUnsafe } from "@thi.ng/paths";
 *
 * const g = defGetterUnsafe("a.b.c");
 *
 * console.log(g({ a: { b: { c: 23} } }));
 * // 23
 *
 * console.log(g({ x: 23 }));
 * // undefined
 * ```
 *
 * @param path -
 */
export declare const defGetterUnsafe: <T = any>(path: Path) => Fn<any, Maybe<T>>;
/**
 * Creates getter function for given nested lookup path. Returns
 * function which accepts single object and returns value at given path.
 *
 * @remarks
 * Optimized fast execution paths are provided for path lengths <= 4.
 * Only the first 8 path levels are type checked.
 *
 * Supports any `[]`-indexable data structure (arrays, objects,
 * strings).
 *
 * If any intermediate key is not present in the given obj, further
 * descent stops and the function returns `undefined`.
 *
 * If `path` is an empty array, the returned getter will simply return
 * the given state arg (aka identity function).
 *
 * Also see: {@link defGetterUnsafe}, {@link getIn}, {@link getInUnsafe}
 *
 * @example
 * ```ts tangle:../export/def-getter.ts
 * import { defGetter } from "@thi.ng/paths";
 *
 * interface Foo {
 *   a: { b: { c: number; } }
 * }
 *
 * // fully type checked getter
 * const g = defGetter<Foo, "a", "b", "c">(["a","b","c"]);
 *
 * // error (wrong `d` key)
 * // g = defGetter<Foo, "a", "b", "d">(["a","b","d"]);
 *
 * console.log(g({ a: { b: { c: 23} } }));
 * // 23
 *
 * // error
 * console.log(g({ x: 23 }));
 *
 * // error
 * console.log(g());
 * ```
 *
 * @param path -
 */
export declare function defGetter<T>(path: Path0): Fn<T, T>;
export declare function defGetter<T, A>(path: Path1<T, A>): Fn<T, OptPathVal<T, [A]>>;
export declare function defGetter<T, A, B>(path: Path2<T, A, B>): Fn<T, OptPathVal<T, [A, B]>>;
export declare function defGetter<T, A, B, C>(path: Path3<T, A, B, C>): Fn<T, OptPathVal<T, [A, B, C]>>;
export declare function defGetter<T, A, B, C, D>(path: Path4<T, A, B, C, D>): Fn<T, OptPathVal<T, [A, B, C, D]>>;
export declare function defGetter<T, A, B, C, D, E>(path: Path5<T, A, B, C, D, E>): Fn<T, OptPathVal<T, [A, B, C, D, E]>>;
export declare function defGetter<T, A, B, C, D, E, F>(path: Path6<T, A, B, C, D, E, F>): Fn<T, OptPathVal<T, [A, B, C, D, E, F]>>;
export declare function defGetter<T, A, B, C, D, E, F, G>(path: Path7<T, A, B, C, D, E, F, G>): Fn<T, OptPathVal<T, [A, B, C, D, E, F, G]>>;
export declare function defGetter<T, A, B, C, D, E, F, G, H>(path: Path8<T, A, B, C, D, E, F, G, H>): Fn<T, OptPathVal<T, [A, B, C, D, E, F, G, H]>>;
export declare function defGetter<T, A, B, C, D, E, F, G, H>(path: DeepPath<T, A, B, C, D, E, F, G, H>): Fn<T, any>;
//# sourceMappingURL=getter.d.ts.map