import { ValueOf } from 'ts-essentials';
/** Convenience empty record type. */
export type Empty = Record<string, never>;
/** Checks whether two objects are deeply equal. */
export declare function isDeepEqual(arg1: unknown, arg2: unknown): boolean;
/** Wraps an object, adding a freeze method. */
export declare function freezable<O extends object>(val: O, opts?: FreezableOptions<O>): [O, Freezer];
export interface FreezableOptions<O> {
    readonly allowList?: ReadonlyArray<Exclude<keyof O, number>>;
    readonly onFreeze?: (obj: O) => void;
}
export type Freezer = () => void;
export type TrimUndefined<T extends unknown[]> = T extends [] ? [] : T extends [infer H, ...infer R] ? TrimUndefined<R> extends [] ? H extends undefined ? [] : [H] : T : never;
/** ADT visitor type. */
export type Visit<O, V = void, C = undefined> = (o: O, ...rest: TrimUndefined<[C]>) => V;
/**
 * Generates a discriminated union type.
 *
 * Sample usage:
 *
 *  ```
 *  type D = KindAmong<{
 *    fooN: {readonly n: number};
 *    barV: {readonly v: string};
 *  }>;
 *  const d: D = {kind: 'fooN', n: 123};
 *  ```
 */
export type KindAmong<O> = ValueOf<BranchValues<O>>;
/** Convenience type representing a single discriminating branch. */
export interface HasKind<K extends string = string> {
    readonly kind: K;
}
type BranchValues<O> = {
    [K in keyof O & string]: ValueOf<Branch<O, K>> & HasKind<K>;
};
/** Asserts that the object matches the given branch. */
export declare function assertKind<O extends HasKind, K extends O['kind']>(obj: O, kind: K): asserts obj is O & HasKind<K>;
/** `KindAmong` visitor. */
export type WalkerFor<O extends HasKind, V, C> = {
    readonly [K in O['kind'] as `on${Capitalize<K>}`]: (o: O & HasKind<K>, c: C) => V;
};
/** Returns a visitor for `KindAmong` ADTs. */
export declare function walkWith<O extends HasKind, V = void, C = undefined>(walker: WalkerFor<O, V, C>): Visit<O, V, C>;
/**
 * Generates a "oneof" union type. This is similar to a discriminated union type
 * but the values remain nested within their separate fields.
 *
 * Sample usage:
 *
 *  ```
 *  type J = JustOne<{
 *    fooN: {readonly n: number};
 *    barV: {readonly v: string};
 *  }>;
 *  const j: J = {just: 'fooN', fooN: {n: 123}}; // Note the `fooN` key here.
 *  ```
 */
export type JustOne<O> = ValueOf<Branches<'just', O>>;
type Branches<K extends string, O> = {
    [B in keyof O]: Branch<O, B> & {
        readonly [N in K]: B;
    };
};
type Branch<O, B1> = {
    readonly [B2 in keyof O as B2 extends B1 ? B2 : never]: O[B2];
};
/**
 * Convenience type filtering on a particular `just` value. This can be useful
 * to narrow `JustOne` types, for example:
 *
 *  ```
 *  type One = JustOne<{foo: Foo; bar: Bar; baz: Baz}>; // foo, bar, or baz.
 *  type Two = Exclude<One, HasJust<'foo'>>; // bar or baz.
 *  ```
 */
export interface HasJust<J extends string = string> {
    readonly just: J;
}
/** Convenience type representing the discriminating branch of `JustOne`. */
export type IsJust<J extends string = string, V = unknown> = HasJust<J> & {
    readonly [K in J]: V;
};
/** Extracts a branch from `JustOne`, narrowing the type appropriately. */
export declare function getJust<O extends HasJust, J extends O['just']>(obj: O, just: J): (J extends keyof O ? O[J] : never) | undefined;
/** Wraps the argument into a `JustOne` compatible value. */
export declare function just<J extends string, V>(j: J, val: V): JustOne<{
    [K in J]: V;
}>;
/** Asserts that the object matches the given branch. */
export declare function assertJust<O extends HasJust, J extends O['just']>(obj: O, just: J): asserts obj is O & HasJust<J>;
/** Checks that the object matches the branch and returns its value. */
export declare function checkJust<O extends HasJust, J extends O['just']>(obj: O, just: J): J extends keyof O ? O[J] : never;
/** `JustOne` visitor. */
export type ExplorerFor<O extends HasJust, V, C> = {
    readonly [J in O['just'] as `on${Capitalize<J>}`]: (o: O extends IsJust<J, infer V> ? V : never, c: C, j: J) => V;
};
/** Returns a visitor for `JustOne` ADTs. */
export declare function exploreWith<O extends HasJust, V = void, C = undefined>(explorer: ExplorerFor<O, V, C>): Visit<O, V, C>;
/**
 * A limited depth version of `DeepWritable`. This is useful since in many cases
 * we want to keep the immutability of nested values and only allow modifying
 * the outer object's keys and collections. The optional second argument can be
 * used to allowlist fields for nested modification.
 */
export type Modifiable<O, K extends keyof O = never> = {
    -readonly [P in keyof O]: O[P] extends ReadonlyMap<infer K, infer V> ? Map<K, V> : O[P] extends ReadonlySet<infer V> ? Set<V> : O[P] extends ReadonlyArray<infer V> ? V[] : P extends K ? Modifiable<O[P]> : O[P];
};
/**
 * Marks properties in a type as present (required and non-nullable). The
 * `readonly`-ness of properties is preserved.
 */
export type MarkPresent<O extends object, F extends keyof O = keyof O> = Omit<O, F> & {
    [K in F]-?: NonNullable<O[K]>;
};
/**
 * Fits data within a given length, potentially truncating it. This function is
 * relatively expensive and shouldn't be called on critical paths (i.e. prefer
 * guarding it with log-level enabled checks).
 */
export declare function contained(data: unknown, opts?: {
    readonly maxLength?: number;
}): Contained;
export interface Contained {
    /** Stringified size of the contained data. */
    readonly size: number;
    /** Approximate loss, absent if lossless. */
    readonly loss?: number;
    /** Potentially truncated data, fit to container. */
    readonly data: unknown;
}
/**
 * Mutates the input in-place, deleting all (potentially nested) keys pointing
 * to `undefined` values. Note that `null` values are kept. Arrays and maps are
 * traversed.
 */
export declare function stripUndefinedValues(arg: unknown): void;
/** Type-safe mapping over an object's values */
export declare function mapValues<K extends string | number | symbol, V, W>(obj: {
    readonly [P in K]: V;
}, fn: (val: V, key: K) => W): {
    readonly [P in K]: W;
};
export interface PrettyFormatterOptions {
    readonly stringThreshold?: number;
    readonly arrayThreshold?: number;
    readonly binaryArrayThreshold?: number;
}
/** Object pretty formatter */
export declare class PrettyFormatter {
    private readonly stringPadding;
    private readonly arrayPadding;
    private readonly binaryArrayPadding;
    private constructor();
    static create(opts?: PrettyFormatterOptions): PrettyFormatter;
    format(arg: unknown): unknown;
    private formatString;
    private formatRelativeIndexable;
    private formatBuffer;
}
export {};