export declare type Nullable<T> = T | null | undefined;
export declare type ObjectValue<T> = T[keyof T];
export declare type OneOrMoreReadonlyArray<T> = readonly [T, ...T[]];
export declare type PartialWithUndefined<T> = {
    [P in keyof T]?: T[P] | undefined;
};
export declare type RequiredExcludeUndefined<T> = {
    [P in keyof T]-?: Exclude<T[P], undefined>;
};
/**
 * The built-in `AsyncIterable` type does not have the `TReturn` and `TNext` arguments.
 * This type fixes that problem and makes it easier to use with function return types.
 *
 * Note: Do not specify the `never` type for the `TNext` argument!
 *       It will not be available for the for-await-of statement.
 */
export interface AsyncIterableReturn<T, TReturn, TNext = undefined> {
    [Symbol.asyncIterator]: () => AsyncIterator<T, TReturn, TNext>;
}
/**
 * The built-in `AsyncIterableIterator` type does not have the `TReturn` and `TNext` arguments.
 * This type fixes that problem and makes it easier to use with function return types.
 *
 * Note: Do not specify the `never` type for the `TNext` argument!
 *       It will not be available for the for-await-of statement.
 */
export interface AsyncIterableIteratorReturn<T, TReturn, TNext = undefined> extends AsyncIterator<T, TReturn, TNext> {
    [Symbol.asyncIterator]: () => AsyncIterableIteratorReturn<T, TReturn, TNext>;
}
export declare function assertType<T>(_: T): void;
export declare type isInteger = (value: unknown) => value is number;
export declare type objectEntries = <T extends string, U>(o: Record<T, U>) => Array<[T, U]>;
export declare type objectFromEntries = <K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>) => Record<K, T>;
export declare type Cond<TCond extends Record<'actual' | 'expected', unknown>, TResult extends Record<'match' | 'notMatch', unknown>> = [TCond['expected']] extends [TCond['actual']] ? [TCond['actual']] extends [TCond['expected']] ? TResult['match'] : TResult['notMatch'] : TResult['notMatch'];
export declare type Cond2<T extends Record<'allMatch' | 'notAllMatch', unknown> & Record<'cond1' | 'cond2', Record<'actual' | 'expected' | 'onlyMatch', unknown>>> = Cond<T['cond1'], {
    match: Cond<T['cond2'], {
        match: T['allMatch'];
        notMatch: T['cond1']['onlyMatch'];
    }>;
    notMatch: Cond<T['cond2'], {
        match: T['cond2']['onlyMatch'];
        notMatch: T['notAllMatch'];
    }>;
}>;