/// <reference types="node" />
import type { AsyncIterableReturn, PartialWithUndefined } from './type';
export declare function isNotUndefined<T>(value: T): value is Exclude<T, undefined>;
export declare function ifFuncThenExec<TArgs extends unknown[], TResult, TOther>(value: ((...args: TArgs) => TResult) | TOther, ...args: TArgs): TResult | TOther;
export declare function getPropFromValue<T extends string, U>(rec: Record<T, U>, value: U): T | null;
/**
 * Normalize the input options to exclude properties with `undefined` values.
 * This is similar to copying an object with the spread syntax,
 * except that it excludes the `undefined` value of the source property.
 * @example
 * ```
 * const defaultOptions = { foo: 'bar', type: 'default' };
 * const inputOptions = { type: undefined };
 *
 * // Before:
 * const normalizedOptions = { ...defaultOptions, ...inputOptions };
 * //=> { foo: 'bar', type: undefined }
 * // Oops! The `type` property should not be overwritten!
 *
 * // After:
 * const normalizedOptions = normalizeOptions(defaultOptions, inputOptions);
 * //=> { foo: 'bar', type: 'default' }
 * // 👍
 * ```
 */
export declare function normalizeOptions<T extends object>(defaultOptions: Readonly<Required<T>>, ...optionsList: Array<Readonly<PartialWithUndefined<T>>>): T;
export declare function bufferFrom(value: Buffer | NodeJS.ArrayBufferView | ArrayBufferLike): Buffer;
export declare function bufferFrom(value: string | Buffer | NodeJS.ArrayBufferView | ArrayBufferLike): Buffer | string;
export declare function bufferFrom(value: string | Buffer | NodeJS.ArrayBufferView | ArrayBufferLike, encoding: BufferEncoding): Buffer;
export declare function asyncIterable2Buffer(iterable: AsyncIterable<Buffer>): Promise<Buffer>;
export declare function convertIterableValue<T, U>(iterable: Iterable<T> | AsyncIterable<T>, converter: (value: T) => U): AsyncIterableReturn<U, void>;
export declare function number2hex(template: TemplateStringsArray, ...substitutions: number[]): string;
export declare function printObject(value: unknown, opts?: {
    passThroughString?: boolean | undefined;
}): string;
interface CondResult<TArg, TPrevResult> {
    case: <Tvalue extends TArg, TResult>(typeGuard: (value: TArg) => value is Tvalue, convert: (value: Tvalue) => TResult) => CondResult<Exclude<TArg, Tvalue>, TPrevResult | TResult>;
    default: <TResult>(convert: (value: TArg) => TResult) => TPrevResult | TResult;
}
export declare function cond<T, U = never>(value: T): CondResult<T, U>;
export declare function fixNodePrimordialsErrorInstance(oldError: unknown): never;
/**
 * The Node.js built-in function throws a pseudo Error object that does not extend the Error object.
 * Their stack trace is incomplete and errors are difficult to trace.
 * For example, the results of {@link https://jestjs.io/ Jest} do not show where the error occurred.
 * This function will fix the stack trace of the pseudo Error object to the proper one.
 */
export declare function fixNodePrimordialsErrorStackTrace(oldError: unknown): never;
export {};