/**
 * A self contained signal function, when an argument is present it
 * writes to the signal, when theres no argument it reads the signal.
 *
 * @template T
 * @param {T} [value] - Optional initial value
 * @returns {SignalFunction<T>}
 */
export function signalFunction<T>(value?: T): SignalFunction<T>;
/**
 * Runs a function inside an effect if value is a function
 *
 * @param {unknown} value
 * @param {(value: unknown, prev?: unknown) => unknown} fn
 */
export function withPrevValue(value: unknown, fn: (value: unknown, prev?: unknown) => unknown): void;
/**
 * Returns `true` when all derived has been resolved
 *
 * @template {Derived<any>} T
 * @param {...T} args
 * @returns {boolean}
 * @url https://pota.quack.uy/isResolved
 */
export function isResolved<T extends Derived<any>>(...args: T[]): boolean;
/**
 * Creates an asynchronously effect
 *
 * @param {(currentRunningEffect: Promise<any>) => any} fn - A
 *   function that receives a `currentRunningEffect` that should be
 *   awaited for when wanting to run effects synchronously, that's it
 *   one effect after another.
 * @returns {void}
 * @url https://pota.quack.uy/asyncEffect
 */
export function asyncEffect(fn: (currentRunningEffect: Promise<any>) => any): void;
/**
 * Same as signal but writing to it patches current data. To be used
 * to patch a signal array with data that comes from a server without
 * losing references to what its already there avoiding a store.
 *
 * @template {{ id?: string | number; [key: string]: any }[]} T
 * @param {T} initialValue
 * @param {SignalOptions<T>} [options]
 * @returns {Signal<T>}
 * @url https://pota.quack.uy/externalSignal
 */
export function externalSignal<T extends {
    id?: string | number;
    [key: string]: any;
}[]>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
/**
 * Resolves and returns `children` in a memo. A memo in a memo, so
 * reactivity on the inner memo doesnt trigger reactivity outside.
 *
 * @template {JSX.Element} T
 * @param {T | (() => T)} fn
 * @returns {SignalAccessor<Resolved<T>>}
 * @url https://pota.quack.uy/resolve
 */
export function resolve<T extends JSX.Element>(fn: T | (() => T)): SignalAccessor<Resolved<T>>;
/**
 * Recursively unwrap children functions
 *
 * @template T
 * @param {T} children
 * @returns {Resolved<T>}
 * @url https://pota.quack.uy/unwrap
 */
export function unwrap<T>(children: T): Resolved<T>;
/**
 * Makes of `children` a function. Reactive children will run as is,
 * non-reactive children will run untracked, regular children will
 * just return.
 *
 * @template {JSX.Element | JSX.Element[]} T
 * @param {T} children
 * @returns {(...args: unknown[]) => T}
 * @url https://pota.quack.uy/makeCallback
 */
export function makeCallback<T extends JSX.Element | JSX.Element[]>(children: T): (...args: unknown[]) => T;
/**
 * Marks a function as a `Component`.
 *
 * Allows to tell a `signal function` from a `component function`.
 * Signals and user functions go in effects, for reactivity.
 * Components and callbacks are untracked and wont go in effects to
 * avoid re-rendering if signals are used in the components body
 *
 * @url https://pota.quack.uy/markComponent
 */
export function markComponent(fn: any): any;
/**
 * Adds an event listener to a node
 *
 * @template {Document | typeof window | DOMElement} TargetElement
 * @template {JSX.EventName} Name
 * @param {TargetElement} node - Element to add the event listener
 * @param {Name} type - The name of the event listener
 * @param {JSX.EventHandler<JSX.EventTypeFor<Name>, TargetElement>} handler
 *   - Function to handle the event
 *
 * @returns {Function} - An `off` function for removing the event
 *   listener
 * @url https://pota.quack.uy/addEvent
 */
export function addEvent<TargetElement extends Document | typeof window | DOMElement, Name extends JSX.EventName>(node: TargetElement, type: Name, handler: JSX.EventHandler<JSX.EventTypeFor<Name>, TargetElement>): Function;
/**
 * Removes an event listener from a node
 *
 * @template {Document | typeof window | DOMElement} TargetElement
 * @template {JSX.EventName} Name
 * @param {TargetElement} node - Element to add the event listener
 * @param {Name} type - The name of the event listener
 * @param {JSX.EventHandler<JSX.EventTypeFor<Name>, TargetElement>} handler
 *   - Function to handle the event
 *
 * @returns {Function} - An `on` function for adding back the event
 *   listener
 * @url https://pota.quack.uy/removeEvent
 */
export function removeEvent<TargetElement extends Document | typeof window | DOMElement, Name extends JSX.EventName>(node: TargetElement, type: Name, handler: JSX.EventHandler<JSX.EventTypeFor<Name>, TargetElement>): Function;
export function ref<T extends DOMElement>(): SignalFunction<T>;
export function microtask(fn: () => unknown): void;
/**
 * Reactive Map
 *
 * @type {{
 * 	<T>(
 * 		list: Each<T>,
 * 		callback: (item: T, index: () => number) => JSX.Element,
 * 		noSort: boolean | undefined,
 * 		fallback: JSX.Element | undefined,
 * 		reactiveIndex: true,
 * 	): (fn?: Function) => JSX.Element
 * 	<T>(
 * 		list: Each<T>,
 * 		callback: (item: T, index: number) => JSX.Element,
 * 		noSort?: boolean,
 * 		fallback?: JSX.Element,
 * 		reactiveIndex?: boolean,
 * 	): (fn?: Function) => JSX.Element
 * }}
 * @url https://pota.quack.uy/map
 */
export const map: {
    <T>(list: Each<T>, callback: (item: T, index: () => number) => JSX.Element, noSort: boolean | undefined, fallback: JSX.Element | undefined, reactiveIndex: true): (fn?: Function) => JSX.Element;
    <T>(list: Each<T>, callback: (item: T, index: number) => JSX.Element, noSort?: boolean, fallback?: JSX.Element, reactiveIndex?: boolean): (fn?: Function) => JSX.Element;
};
/**
 * Extend `Pota` and define a `render(){}` method to create a class
 * component. `ready(cb)` and `cleanup(cb)` methods will be registered
 * automatically.
 *
 * JSX props become `Partial<P>` via `JSX.LibraryManagedAttributes` —
 * the renderer merges JSX props on top of the `props` field defaults
 * (see `createClass` in `src/core/renderer.js`), so every individual
 * JSX prop is optional at the call site. Inside `render()`, the
 * parameter is the full `P`.
 *
 * @template {Record<string, unknown>} [P=Record<string, unknown>]
 *   Default is `Record<string, unknown>`
 * @url https://pota.quack.uy/Pota
 */
export class Pota<P extends Record<string, unknown> = Record<string, unknown>> {
    /** @param {P} props */
    constructor(props: P);
    /** @type {P} */
    props: P;
    /** @param {P} props */
    render(props: P): void;
}
export function isComponent(value: any): boolean;
export function ownedEvent<T extends JSX.EventHandler<Event, Element>>(handler: T): ((...args: any[]) => any) | (T & {
    handleEvent: (...args: any[]) => any;
});
export const action: typeof import("../../typescript/private/action.js").action;
export const asyncTracking: {
    add: () => () => void;
    ready: (fn: any) => void;
};
export const batch: <T>(fn: () => T, init?: boolean) => T;
export const catchError: <T>(fn: () => T, handler: (err: unknown) => void) => T | undefined;
export const cleanup: <T extends () => void>(fn: T) => T;
export const context: <T>(defaultValue?: T) => Context<T>;
export const createSuspenseContext: {
    new (): {
        s: Signal<boolean>;
        c: number;
        add(): () => void;
        isEmpty(): boolean;
    };
};
export const derived: typeof import("../../typescript/private/derived.js").derived;
export const effect: <T>(fn: () => T, options?: EffectOptions) => void;
export const listener: () => {
    state: number;
    updatedAt: number;
    fn: Function | undefined;
    sources: any[];
    sourceSlots: number[];
    update(): void;
    dispose(): void;
    queue(): void;
    owner: undefined | {
        owner: undefined | /*elided*/ any;
        owned: /*elided*/ any[];
        cleanups: Function[];
        context: Record<symbol, unknown>;
        addCleanups(fn: () => void): void;
        cleanupCancel(fn: () => void): void;
        addOwned(value: /*elided*/ any): void;
        dispose(): void;
        disposeOwned(): void;
        doCleanups(): void;
    };
    owned: /*elided*/ any[];
    cleanups: Function[];
    context: Record<symbol, unknown>;
    addCleanups(fn: () => void): void;
    cleanupCancel(fn: () => void): void;
    addOwned(value: /*elided*/ any): void;
    disposeOwned(): void;
    doCleanups(): void;
};
export const memo: <T>(fn: () => T, options?: SignalOptions<T>) => SignalAccessor<T> & {
    readonly memo?: void;
};
export const on: <T>(depend: () => any, fn: () => T, options?: EffectOptions) => void;
export const owned: <T, A>(cb: ((...args: A[]) => T) | Function, onCancel?: () => void) => (...args: any[]) => any;
export const owner: () => {
    state: number;
    updatedAt: number;
    fn: Function | undefined;
    sources: any[];
    sourceSlots: number[];
    update(): void;
    dispose(): void;
    queue(): void;
    owner: undefined | {
        owner: undefined | /*elided*/ any;
        owned: /*elided*/ any[];
        cleanups: Function[];
        context: Record<symbol, unknown>;
        addCleanups(fn: () => void): void;
        cleanupCancel(fn: () => void): void;
        addOwned(value: /*elided*/ any): void;
        dispose(): void;
        disposeOwned(): void;
        doCleanups(): void;
    };
    owned: /*elided*/ any[];
    cleanups: Function[];
    context: Record<symbol, unknown>;
    addCleanups(fn: () => void): void;
    cleanupCancel(fn: () => void): void;
    addOwned(value: /*elided*/ any): void;
    disposeOwned(): void;
    doCleanups(): void;
};
export const root: <T>(fn: (dispose: () => void) => T, options?: EffectOptions) => T;
export const Root: {
    new (owner: {
        state: number;
        updatedAt: number;
        fn: Function | undefined;
        sources: any[];
        sourceSlots: number[];
        update(): void;
        dispose(): void;
        queue(): void;
        owner: undefined | {
            owner: undefined | /*elided*/ any;
            owned: /*elided*/ any[];
            cleanups: Function[];
            context: Record<symbol, unknown>;
            addCleanups(fn: () => void): void;
            cleanupCancel(fn: () => void): void;
            addOwned(value: /*elided*/ any): void;
            dispose(): void;
            disposeOwned(): void;
            doCleanups(): void;
        };
        owned: /*elided*/ any[];
        cleanups: Function[];
        context: Record<symbol, unknown>;
        addCleanups(fn: () => void): void;
        cleanupCancel(fn: () => void): void;
        addOwned(value: /*elided*/ any): void;
        disposeOwned(): void;
        doCleanups(): void;
    }, options?: EffectOptions): {
        owner: undefined | /*elided*/ any;
        owned: {
            state: number;
            updatedAt: number;
            fn: Function | undefined;
            sources: any[];
            sourceSlots: number[];
            update(): void;
            dispose(): void;
            queue(): void;
            owner: undefined | /*elided*/ any;
            owned: /*elided*/ any[];
            cleanups: Function[];
            context: Record<symbol, unknown>;
            addCleanups(fn: () => void): void;
            cleanupCancel(fn: () => void): void;
            addOwned(value: /*elided*/ any): void;
            disposeOwned(): void;
            doCleanups(): void;
        }[];
        cleanups: Function[];
        context: Record<symbol, unknown>;
        addCleanups(fn: () => void): void;
        cleanupCancel(fn: () => void): void;
        addOwned(value: {
            state: number;
            updatedAt: number;
            fn: Function | undefined;
            sources: any[];
            sourceSlots: number[];
            update(): void;
            dispose(): void;
            queue(): void;
            owner: undefined | /*elided*/ any;
            owned: /*elided*/ any[];
            cleanups: Function[];
            context: Record<symbol, unknown>;
            addCleanups(fn: () => void): void;
            cleanupCancel(fn: () => void): void;
            addOwned(value: /*elided*/ any): void;
            disposeOwned(): void;
            doCleanups(): void;
        }): void;
        dispose(): void;
        disposeOwned(): void;
        doCleanups(): void;
    };
};
export const runWithOwner: (owner: any, fn: any) => any;
export const signal: <T>(value?: T, options?: SignalOptions<T>) => Signal<T>;
export const syncEffect: <T>(fn: () => T, options?: EffectOptions) => void;
export const untrack: <T>(fn: () => T) => T;
export const useSuspense: Context<{
    s: Signal<boolean>;
    c: number;
    add(): () => void;
    isEmpty(): boolean;
}>;
export const withValue: <T>(value: Attribute<T>, fn: (value: T) => void, writeDefaultValue?: () => void, wroteValue?: any, resolved?: any) => void;
import { createReactiveSystem } from './solid.js';
export { createReactiveSystem };
//# sourceMappingURL=reactive.d.ts.map