import type { Fiber } from "react-reconciler";
import type { Jsonifiable } from "type-fest";
import type { AnyFunction } from "../types";
import { SettingsManager } from "./apis/settings";
/**
 * Loads a stylesheet into the document
 * @param path Path to the stylesheet
 * @returns Link element
 */
export declare const loadStyleSheet: (path: string) => HTMLLinkElement;
/**
 * Wait for an element to be added to the DOM
 * @param selector Element selector
 */
export declare function waitFor(selector: string): Promise<Element>;
/**
 * Async sleep function
 */
export declare function sleep(ms: number): Promise<void>;
/**
 * Get the React instance of an element
 * @param element Element to get the React instance of
 * @returns React instance
 * @throws If the React instance could not be found
 */
export declare function getReactInstance(element: Element): Fiber | null;
/**
 * Get the React owner instance of an element
 * @param element Element to get the React owner instance of
 * @returns React owner instance
 * @throws If the React owner instance could not be found
 */
export declare function getOwnerInstance(element: Element): React.Component & Record<string, unknown>;
/**
 * Force updates a rendered React component by its DOM selector
 * @param selector The DOM selector to force update
 * @param all Whether all elements matching that selector should be force updated
 */
export declare function forceUpdateElement(selector: string, all?: boolean): void;
/**
 * If the user is not in the server, join it. Otherwise, go to the server.
 * @param invite Invite code (eg "replugged")
 */
export declare function goToOrJoinServer(invite: string): Promise<void>;
export declare function openExternal(url: string): Promise<void>;
type InputType<T> = T | React.ChangeEvent<HTMLInputElement> | (Record<string, unknown> & {
    value?: T;
    checked?: T;
});
type ObjectPath<T> = T extends Record<string, unknown> ? {
    [K in keyof T]-?: K extends string ? `${K}` | `${K}.${ObjectPath<T[K]>}` : never;
}[keyof T] : never;
type ValueAtPath<T, P> = P extends `${infer K}.${infer NestedKey}` ? K extends keyof T ? ValueAtPath<NonNullable<T[K]>, NestedKey> : undefined : P extends keyof T ? NonNullable<T[P]> : undefined;
type InferredPath<T extends Record<string, Jsonifiable>, D extends keyof T, K extends Extract<keyof T, string>, P extends ObjectPath<T>, F extends ValueAtPath<T, P> | T[K] | undefined> = P extends `${K}.${string}` ? NonNullable<ValueAtPath<T, P>> : P extends D ? NonNullable<T[P]> : F extends null | undefined ? T[P] | undefined : NonNullable<T[P]> | F;
/**
 * React hook for managing settings.
 * @param settings Settings manager to use.
 * @param key Key of the setting to manage.
 * @param fallback Value to return if the key does not already exist.
 * @returns A tuple containing the current value of the setting, and a function to set the value. Works like `useState`.
 * @example
 * ```tsx
 * import { components, settings } from "replugged";
 * const { TextInput } = components;
 *
 * const cfg = settings.init<{ hello: string }>("dev.replugged.Example");
 *
 * export function Settings() {
 *  return <TextInput {...cfg.useSetting("hello", "world")} />;
 * }
 * ```
 */
export declare function useSetting<Settings extends Record<string, Jsonifiable>, Defaults extends keyof Settings, PathKey extends Extract<keyof Settings, string>, Fallback extends ValueAtPath<Settings, Path> | Settings[PathKey] | undefined, Path extends ObjectPath<Settings>, Value extends InferredPath<Settings, Defaults, PathKey, Path, Fallback>>(settings: SettingsManager<Settings, Defaults>, key: Path, fallback?: Fallback): {
    value: Value;
    onChange: (newValue: InputType<ValueAtPath<Settings, Path>> | InputType<Settings[PathKey]>) => void;
};
export declare function useSettingArray<Settings extends Record<string, Jsonifiable>, Defaults extends keyof Settings, PathKey extends Extract<keyof Settings, string>, Fallback extends ValueAtPath<Settings, Path> | Settings[PathKey] | undefined, Path extends ObjectPath<Settings>, Value extends InferredPath<Settings, Defaults, PathKey, Path, Fallback>>(settings: SettingsManager<Settings, Defaults>, key: Path, fallback?: Fallback): [
    Value,
    (newValue: InputType<ValueAtPath<Settings, Path>> | InputType<Settings[PathKey]>) => void
];
type UnionToIntersection<U> = (U extends never ? never : (k: U) => void) extends (k: infer I) => void ? I & {
    all: () => I;
} : never;
type ObjectType = Record<never, never>;
type ExtractObjectType<O extends ObjectType[]> = O extends Array<infer T> ? UnionToIntersection<T> : never;
export declare function virtualMerge<O extends ObjectType[]>(...objects: O): ExtractObjectType<O>;
export type Tree = Record<string, unknown> | null;
type TreeFilter = string | ((tree: Tree) => boolean);
/**
 * All credit goes to rauenzi for writing up this implementation.
 * You can find the original source here:
 * <https://github.com/rauenzi/BDPluginLibrary/blob/683d6abc70f149a39e2f0433ffb65e55ca47c4e3/release/0PluginLibrary.plugin.js#L2585C15-L2611>
 *
 * @remarks Used mainly in findInReactTree
 */
export declare function findInTree(tree: Tree, searchFilter: TreeFilter, args?: {
    walkable?: string[];
    ignore?: string[];
    maxRecursion: number;
}): Tree | null | undefined;
export type ReactTree = (Tree & React.ReactElement) | Tree;
type ReactTreeFilter = string | ((reactTree: ReactTree) => boolean);
/**
 * Find the component you are looking for in a tree, recursively.
 *
 * @param tree The tree to search through
 * @param searchFilter The filter. Either a string or a function. Should be unique
 * @param maxRecursion The max depth. Avoids call stack exceeded error.
 * @returns The component you are looking for
 */
export declare function findInReactTree(tree: ReactTree, searchFilter: ReactTreeFilter, maxRecursion?: number): ReactTree | null | undefined;
type MethodNames<T> = {
    [K in keyof T]: T[K] extends AnyFunction ? K : never;
}[keyof T];
type BoundMethodMap<T> = {
    [K in MethodNames<T>]: T[K];
};
/**
 * Creates a new object containing all methods from the prototype of the given instance,
 * with each method bound to the original instance.
 *
 * @template T The type of the instance object
 * @param instance The object instance whose methods should be bound
 * @returns A new object containing all prototype methods bound to the original instance
 */
export declare function getBoundMethods<T extends object>(instance: T): BoundMethodMap<T>;
export declare const mapClassNames: <T extends Record<string, string>>(object: T) => T;
export {};