/**
 * Iterates over own enumerable string and symbol keys.
 *
 * @param {Record<PropertyKey, unknown>} target
 * @returns {IterableIterator<[PropertyKey, unknown]>}
 */
export function entriesIncludingSymbols(target: Record<PropertyKey, unknown>): IterableIterator<[PropertyKey, unknown]>;
/**
 * Compares two values for equality. Handles primitive types, objects,
 * and arrays recursively.
 *
 * @template T
 * @param {T} a - The first value to compare.
 * @param {T} b - The second value to compare.
 * @returns {boolean} True if the values are equal, false otherwise.
 * @url modified version of https://github.com/epoberezkin/fast-deep-equal
 */
export function equals<T_1>(a: T_1, b: T_1): boolean;
export function deepFreeze(o: any): any;
/**
 * Walks a prototype and returns the names of every setter it defines.
 *
 * @param {object} object
 * @param {Set<PropertyKey>} [set]
 * @returns {Set<PropertyKey>}
 */
export function getSetterNamesFromPrototype(object: object, set?: Set<PropertyKey>): Set<PropertyKey>;
/**
 * Unwraps values. If the argument is a function then it runs it
 * recursively and returns the value
 *
 * @template T
 * @param {Accessor<T>} value - Maybe function
 * @returns T
 * @url https://pota.quack.uy/getValue
 */
export function getValue<T_1>(value: Accessor<T_1>): T_1;
export function range(start: any, stop: any, step: any): Generator<any, void, unknown>;
/**
 * Removes a value from an array
 *
 * @template T
 * @param {T[]} array
 * @param {T} value To remove from the array
 */
export function removeFromArray<T_1>(array: T_1[], value: T_1): void;
/**
 * Removes values from an array based on a condition
 *
 * @template T
 * @param {T[]} array
 * @param {(index: number, value: T) => boolean} cb Function with
 *   condition
 */
export function removeFromArrayConditionally<T_1>(array: T_1[], cb: (index: number, value: T_1) => boolean): void;
/**
 * Removes values from an array based on a condition
 *
 * @template T
 * @param {Iterable<T>} iterable
 * @param {PropertyKey} key Function with condition
 */
export function indexByKey<T_1>(iterable: Iterable<T_1>, key: PropertyKey): any;
/**
 * Walks up a linked structure invoking `cb` for each parent until
 * `cb` returns `true`.
 *
 * @param {object} context
 * @param {PropertyKey} propertyName
 * @param {(value: any) => boolean | void} cb
 * @returns {boolean} Whether the callback succeeded.
 */
export function walkParents(context: object, propertyName: PropertyKey, cb: (value: any) => boolean | void): boolean;
export const window: Window & typeof globalThis;
export const requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof globalThis.requestAnimationFrame;
export const cancelAnimationFrame: ((handle: number) => void) & typeof globalThis.cancelAnimationFrame;
export const queueMicrotask: ((callback: VoidFunction) => void) & typeof globalThis.queueMicrotask;
export const history: History;
export const navigator: Navigator;
export const location: Location;
export const origin: string;
export const Object: ObjectConstructor;
export const Array: ArrayConstructor;
export const Promise: PromiseConstructor;
export const Symbol: SymbolConstructor;
export const assign: {
    <T_1 extends {}, U>(target: T_1, source: U): T_1 & U;
    <T_1 extends {}, U, V>(target: T_1, source1: U, source2: V): T_1 & U & V;
    <T_1 extends {}, U, V, W>(target: T_1, source1: U, source2: V, source3: W): T_1 & U & V & W;
    (target: object, ...sources: any[]): any;
};
export const create: {
    (o: object | null): any;
    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
};
export const defineProperties: <T_1>(o: T_1, properties: PropertyDescriptorMap & ThisType<any>) => T_1;
export const defineProperty: <T_1>(o: T_1, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T_1;
export const entries: {
    <T_1>(o: {
        [s: string]: T_1;
    } | ArrayLike<T_1>): [string, T_1][];
    (o: {}): [string, any][];
};
export const freeze: {
    <T_1 extends Function>(f: T_1): T_1;
    <T_1 extends {
        [idx: string]: U | null | undefined | object;
    }, U extends string | bigint | number | boolean | symbol>(o: T_1): Readonly<T_1>;
    <T_1>(o: T_1): Readonly<T_1>;
};
export const isFrozen: (o: any) => boolean;
export const fromEntries: {
    <T_1 = any>(entries: Iterable<readonly [PropertyKey, T_1]>): {
        [k: string]: T_1;
    };
    (entries: Iterable<readonly any[]>): any;
};
export const getOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
export const getOwnPropertyDescriptors: <T_1>(o: T_1) => { [P in keyof T_1]: TypedPropertyDescriptor<T_1[P]>; } & {
    [x: string]: PropertyDescriptor;
};
export const getOwnPropertyNames: (o: any) => string[];
export const getOwnPropertySymbols: (o: any) => symbol[];
export const getPrototypeOf: (o: any) => any;
export const groupBy: <K extends PropertyKey, T_1>(items: Iterable<T_1>, keySelector: (item: T_1, index: number) => K) => Partial<Record<K, T_1[]>>;
export const hasOwn: (o: object, v: PropertyKey) => boolean;
export const is: (value1: any, value2: any) => boolean;
export const isExtensible: (o: any) => boolean;
export const keys: {
    (o: object): string[];
    (o: {}): string[];
};
export const values: {
    <T_1>(o: {
        [s: string]: T_1;
    } | ArrayLike<T_1>): T_1[];
    (o: {}): any[];
};
export const setPrototypeOf: (o: any, proto: object | null) => any;
export const toArray: {
    <T_1>(arrayLike: ArrayLike<T_1>): T_1[];
    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
    <T_1>(iterable: Iterable<T_1> | ArrayLike<T_1>): T_1[];
    <T_1, U>(iterable: Iterable<T_1> | ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
};
export function toValues(value: unknown): Iterable<unknown>;
export function toEntries(value: unknown): Iterable<[unknown, unknown]>;
export const iterator: symbol;
export const Iterator: IteratorConstructor;
export const stringify: {
    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
};
export function stringifyReadable(o: unknown): string;
export function stringifySorted(o: unknown): string;
export function promise(fn: (resolve: (value: unknown) => void, reject: (reason?: any) => void) => void): Promise<unknown>;
export function withResolvers<T_1>(): {
    promise: Promise<T_1>;
    resolve: (value: T_1 | PromiseLike<T_1>) => void;
    reject: (reason?: any) => void;
};
export function resolved(promise: any, onDone: any): any;
export function resolvedIgnoreError(promise: any, onDone: any): any;
export function call(fns: Iterable<Function>): void;
export function flatForEach<T_1 extends unknown | unknown[]>(arr: T_1, fn: (value: T_1) => void): void;
export function redefineProperty<T_1>(target: T_1, key: PropertyKey, descriptor: PropertyDescriptor): T_1;
/**
 * Returns an object without a prototype
 *
 * @type {Function}
 */
export const empty: Function;
/**
 * An empty frozen array
 *
 * @type {readonly unknown[]}
 */
export const emptyArray: readonly unknown[];
/** An empty frozen object */
export const nothing: any;
export function unwrapArray(arr: any[] | NodeListOf<ChildNode>): any;
export function flatToArray<T_1>(arr: T_1 | T_1[]): T_1[];
export function flatNoArray<T_1 extends unknown | unknown[]>(arr: T_1): T_1[] | T_1;
export function withState<T_1 extends ((...args: any[]) => void) & Function>(fn: T_1, state?: () => DataStore<Map<unknown, unknown>>): (...args: Parameters<T_1> extends [any, ...infer P] ? P : never) => ReturnType<T_1>;
export function withCache<T_1, R>(fn: (value: T_1) => R): (value: T_1) => R;
export function withWeakCache<T_1 extends unknown, R>(fn: (value: T_1) => R): (value: T_1) => R;
export function getOwnValues(o: Record<PropertyKey, unknown>): unknown[];
export function getValueWithArguments<T_1>(value: T_1, ...args: unknown[]): T_1;
export function identity<T_1>(x: T_1): T_1;
export function isConfigurable(target: object, key: PropertyKey, value: boolean | undefined): boolean;
export function isFunction<T_1>(value: T_1): value is ((...args: unknown[]) => T_1);
export const isNaN: (number: unknown) => boolean;
export function isIterable(value: unknown): value is Iterable<unknown>;
export function isNullUndefined(value: unknown): value is null | undefined;
export function isObject<T_1>(value: T_1): value is object;
export function isString(value: unknown): value is string;
export function isNumber(value: unknown): value is number;
export function isSymbol(value: unknown): value is symbol;
export function isBoolean(value: unknown): value is boolean;
export function isPromise<T_1>(value: T_1): value is Extract<T_1, PromiseLike<unknown>>;
/**
 * @template T
 * @param {T} value
 * @returns {value is array}
 */
export const isArray: (arg: any) => arg is any[];
export function morphedBetweenArrayAndObject(a: unknown, b: unknown): boolean;
export function isPrototypeProperty(target: object, key: PropertyKey): boolean;
export function isGeneratorFunction(target: any): boolean;
export function noop(): void;
export function optional<T_1>(value: T_1): true | T_1;
export const reflectOwnKeys: typeof Reflect.ownKeys;
export const reflectHas: typeof Reflect.has;
export const reflectDeleteProperty: typeof Reflect.deleteProperty;
export const reflectDefineProperty: typeof Reflect.defineProperty;
export const reflectGetOwnPropertyDescriptor: typeof Reflect.getOwnPropertyDescriptor;
export const reflectGet: typeof Reflect.get;
export const reflectApply: typeof Reflect.apply;
export const reflectSet: typeof Reflect.set;
export const reflectSetPrototypeOf: typeof Reflect.setPrototypeOf;
export const reflectIsExtensible: typeof Reflect.isExtensible;
export function typeString(obj: unknown): string;
export function weakStore(): DataStore<WeakMap<any, any>>;
export function cacheStore(): DataStore<Map<any, any>>;
export function warn(...args: unknown[]): void;
export function error(...args: unknown[]): void;
export function isProxyValueReturnInvariant(target: any, key: any, value: any): boolean;
/** @template {Map<any, any> | WeakMap<any, any>} T */
declare class DataStore<T extends Map<any, any> | WeakMap<any, any>> {
    /** @param {new () => T} kind */
    constructor(kind: new () => T);
    set: ((key: any, value: any) => Map<any, any>) | ((key: any, value: any) => WeakMap<any, any>);
    has: ((key: any) => boolean) | ((key: any) => boolean);
    delete: ((key: any) => boolean) | ((key: any) => boolean);
    get: (target: any, defaults?: any) => any;
    [Symbol.iterator](): Generator<(target: any, defaults?: any) => any, void, unknown>;
}
export {};
//# sourceMappingURL=std.d.ts.map