import type { PromiseOrValue } from "../types.js";
import type { RecordableKeys } from "./types.js";
/**
 * Utility function that allows for piping a series of async functions together
 *
 * @param {((s: S, o?: O, f?: F) => Promise<S>)[]} fns - functions to pipe
 * @returns {S} result of the pipe
 */
export declare const asyncPipe: <S, O, F>(...fns: ((s: S, o?: O, f?: F) => Promise<S>)[]) => (s: S, o?: O, f?: F) => Promise<S>;
export type Deferrable<T> = {
    [K in keyof T]: PromiseOrValue<T[K]>;
};
/**
 * Used to ensure type doesn't extend another, for use in & chaining of properties
 */
export type NotType<A, B> = A extends B ? never : unknown;
/**
 * Await all of the properties of a Deferrable object
 *
 * @param {Deferrable<T>} object - a Deferrable object
 * @returns {Promise<T>} the object with its properties resolved
 */
export declare function resolveProperties<T>(object: Deferrable<T>): Promise<T>;
/**
 * Recursively converts all values in an object to hex strings
 *
 * @param {any} obj - obj to deep hexlify
 * @returns {any} object with all of its values hexlified
 */
export declare function deepHexlify(obj: any): any;
/**
 * Filters out properties with undefined or null values from the provided object.
 *
 * @example
 * ```ts
 * import { filterUndefined } from "@aa-sdk/core";
 *
 * const result = filterUndefined({
 *  foo: undefined,
 *  bar: null,
 *  baz: "baz",
 * }); // { baz: "baz" }
 * ```
 *
 * @param {T} obj the object from which to remove properties with undefined or null values
 * @returns {T} the object with undefined or null properties removed
 */
export declare function filterUndefined<T>(obj: T): T;
/**
 * Picks the specified keys from an object and returns a new object containing only those key-value pairs.
 *
 * @example
 * ```ts
 * import { pick } from "@aa-sdk/core";
 *
 * const picked = pick({
 *  foo: "foo",
 *  bar: "bar",
 * }, ["foo"]); // { foo: "foo" }
 * ```
 *
 * @param {Record<string, unknown>} obj The object from which to pick keys
 * @param {string|string[]} keys A single key or an array of keys to pick from the object
 * @returns {Record<string, unknown>} A new object containing only the picked key-value pairs
 */
export declare function pick(obj: Record<string, unknown>, keys: string | string[]): {};
/**
 * Utility method for checking if the passed in values are all equal (strictly)
 *
 * @param {...any[]} params - values to check
 * @returns {boolean} a boolean indicating if all values are the same
 * @throws if no values are passed in
 */
export declare const allEqual: (...params: any[]) => boolean;
/**
 * Utility method for checking the condition and return the value if condition holds true, undefined if not.
 *
 * @param {Promise<boolean>} condition - condition to check
 * @param {() => Promise<T>} value - value to return when condition holds true
 * @returns {Promise<T | undefined>} the value if condition holds true, undefined if not
 */
export declare const conditionalReturn: <T>(condition: Promise<boolean>, value: () => Promise<T>) => Promise<T | undefined>;
/**
 * Converts an array of objects into a record (object) where each key is determined by the specified selector and the value is determined by the provided function.
 *
 * @example
 * ```ts
 * import { toRecord } from "@aa-sdk/core";
 * import { sepolia, mainnet } from "viem/chains";
 *
 * const addressesByChain = toRecord(
 *  [sepolia, mainnet],
 *  "id",
 *  () => "0x..."
 * ); // { [sepolia.id]: "0x...", [mainnet.id]: "0x..." }
 * ```
 *
 * @param {T[]} array The array of objects to convert to a record
 * @param {K} selector The key used to select the property that will become the record's key
 * @param {(item: T) => V} fn The function that transforms each item in the array into the record's value
 * @returns {Record<T[K], V>} The resulting record object
 */
export declare const toRecord: <T extends { [K_1 in RecordableKeys<T>]: string | number | symbol; }, K extends RecordableKeys<T>, V>(array: T[], selector: K, fn: (item: T) => V) => Record<T[K], V>;
export * from "./bigint.js";
export * from "./bytes.js";
export * from "./defaults.js";
export * from "./schema.js";
export type * from "./types.js";
export * from "./userop.js";