/**
 * Forces the immediate and synchronous execution of all pending reactive updates.
 *
 * Normally, changes to observed data sources (like proxied objects or arrays)
 * are processed asynchronously in a batch after a brief timeout (0ms). This function
 * allows you to bypass the timeout and process the update queue immediately.
 *
 * This can be useful in specific scenarios where you need the DOM to be updated
 * synchronously.
 *
 * This function is re-entrant, meaning it is safe to call `runQueue` from within
 * a function that is itself being executed as part of an update cycle triggered
 * by a previous (or the same) `runQueue` call.
 *
 * @example
 * ```typescript
 * const $data = A.proxy("before");
 *
 * A('#', $data);
 * console.log(1, document.body.innerHTML); // before
 *
 * // Make an update that should cause the DOM to change.
 * $data.value = "after";
 *
 * // Normally, the DOM update would happen after a timeout.
 * // But this causes an immediate update:
 * A.runQueue();
 *
 * console.log(2, document.body.innerHTML); // after
 * ```
 */
export declare function runQueue(): void;
/**
 * Pause processing of reactive updates until the returned *thaw* function is called.
 *
 * While frozen, changes to observed data still accumulate, but no re-renders run. Freezes
 * stack: if there are multiple outstanding freezes, redraws resume only once the last one is
 * thawed. This is useful to batch an async burst of changes into a single update pass, or to
 * hold the UI steady (e.g. the dev tools use it for "freeze redraws").
 *
 * @returns A function that releases this freeze. Calling it more than once has no effect.
 *
 * @example
 * ```typescript
 * const thaw = A.freeze();
 * // ...make many changes without intermediate redraws...
 * thaw(); // redraws run now (if no other freezes remain)
 * ```
 */
export declare function freeze(): () => void;
/**
 * Creates a new string that has the opposite sort order compared to the input string.
 *
 * This is achieved by flipping the bits of each character code in the input string.
 * The resulting string is intended for use as a sort key, particularly with the
 * `makeKey` function in {@link onEach}, to achieve a descending sort order.
 *
 * **Warning:** The output string will likely contain non-printable characters or
 * appear as gibberish and should not be displayed to the user.
 *
 * @example
 * ```typescript
 * const $users = A.proxy([
 *     { id: 1, name: 'Charlie', score: 95 },
 *     { id: 2, name: 'Alice', score: 100 },
 *     { id: 3, name: 'Bob', score: 90 },
 * ]);
 *
 * A.onEach($users, ($user) => {
 *     A(`p#${$user.name}: ${$user.score}`);
 * }, ($user) => A.invertString($user.name)); // Reverse alphabetic order
 * ```
 *
 * @param input The string whose sort order needs to be inverted.
 * @returns A new string that will sort in the reverse order of the input string.
 * @see {@link onEach} for usage with sorting.
 */
export declare function invertString(input: string): string;
export declare function onEach<K, T>(target: Map<K, undefined | T>, render: (value: T, key: K) => void, makeKey?: (value: T, key: K) => SortKeyType): void;
export declare function onEach<T>(target: Set<T>, render: (value: T) => void, makeKey?: (value: T) => SortKeyType): void;
export declare function onEach<T>(target: ReadonlyArray<undefined | T>, render: (value: T, index: number) => void, makeKey?: (value: T, index: number) => SortKeyType): void;
export declare function onEach<K extends string | number | symbol, T>(target: Record<K, undefined | T>, render: (value: T, index: KeyToString<K>) => void, makeKey?: (value: T, index: KeyToString<K>) => SortKeyType): void;
/** @private */
export declare const EMPTY: unique symbol;
/**
 * Reactively checks if an observable array, object, Map, or Set is empty.
 *
 * This function not only returns the current emptiness state but also establishes
 * a reactive dependency. If the emptiness state of the `proxied` object or array
 * changes later (e.g., an item is added to an empty array, or the last property
 * is deleted from an object), the scope that called `isEmpty` will be automatically
 * scheduled for re-evaluation.
 *
 * @param proxied The observable array, object, Map, or Set to check.
 * @returns `true` if the array has length 0, the Map/Set has size 0, or the object has no own enumerable properties, `false` otherwise.
 *
 * @example
 * ```typescript
 * const $items = A.proxy([]);
 *
 * // Reactively display a message if the items array is empty
 * A('div', () => {
 *     if (A.isEmpty($items)) {
 *         A('p i#No items yet!');
 *     } else {
 *         A.onEach($items, item => A('p#'+item));
 *     }
 * });
 *
 * // Adding an item will automatically remove the "No items yet!" message
 * setInterval(() => {
 *   if (!$items.length || Math.random()>0.5) $items.push('Item');
 *   else $items.length = 0;
 * }, 1000)
 * ```
 */
export declare function isEmpty(proxied: TargetType): boolean;
/** @private */
export interface ValueRef<T> {
    value: T;
}
/**
 * Reactively counts the number of properties in an object.
 *
 * @param proxied The observable object to count. In case an `array`, `Map`, or `Set` is passed in, a {@link ref} to its `.length` or `.size` will be returned.
 * @returns an observable object for which the `value` property reflects the number of properties in `proxied` with a value other than `undefined`, or the collection size for arrays, Maps, and Sets.
 *
 * @example
 * ```typescript
 * const $items = A.proxy({x: 3, y: 7} as any);
 * const $count = A.count($items);
 *
 * // Create a DOM text node for the count:
 * A('div text=', $count);
 * // <div>2</div>

 * // Or we can use it in an {@link derive} function:
 * A(() => console.log("The count is now", $count.value));
 * // The count is now 2
 *
 * // Adding/removing items will update the count
 * $items.z = 12;
 * // Asynchronously, after 0ms:
 * // <div>3</div>
 * // The count is now 3
 * ```
 */
export declare function count(proxied: TargetType): ValueRef<number>;
/**
 * When `proxy` is called with a Promise, the returned object has this shape.
 */
export interface PromiseProxy<T> {
    /**
     * True if the promise is still pending, false if it has resolved or rejected.
     */
    busy: boolean;
    /**
     * If the promise has resolved, this contains the resolved value.
     */
    value?: T;
    /**
     * If the promise has rejected, this contains the rejection error.
     */
    error?: any;
}
export declare function proxy<T extends any>(target: Promise<T>): PromiseProxy<T>;
export declare function proxy<T extends any>(target: Array<T>): Array<T extends number ? number : T extends string ? string : T extends boolean ? boolean : T>;
export declare function proxy<T extends object>(target: T): T;
export declare function proxy<T extends any>(target: T): ValueRef<T extends number ? number : T extends string ? string : T extends boolean ? boolean : T>;
/**
 * Returns the original, underlying data target from a reactive proxy created by {@link proxy}.
 * If the input `target` is not a proxy, it is returned directly.
 *
 * This is useful when you want to avoid triggering subscriptions during read operations or
 * re-executes during write operations. Using {@link peek} is an alternative way to achieve this.
 *
 * @param target - A proxied object, array, or any other value.
 * @returns The underlying (unproxied) data, or the input value if it wasn't a proxy.
 * @template T - The type of the target.
 *
 * @example
 * ```typescript
 * const $user = A.proxy({ name: 'Frank' });
 * const rawUser = A.unproxy($user);
 *
 * // Log reactively
 * A(() => console.log('proxied', $user.name));
 * // The following will only ever log once, as we're not subscribing to any observable
 * A(() => console.log('unproxied', rawUser.name));
 *
 * // This cause the first log to run again:
 * setTimeout(() => $user.name += '!', 1000);
 *
 * // This doesn't cause any new logs:
 * setTimeout(() => rawUser.name += '?', 2000);
 *
 * // Both $user and rawUser end up as `{name: 'Frank!?'}`
 * setTimeout(() => {
 *   console.log('final proxied', $user)
 *   console.log('final unproxied', rawUser)
 * }, 3000);
 * ```
 */
export declare function unproxy<T>(target: T): T;
/**
 * Recursively copies properties or array items from `src` to `dst`.
 * It's designed to work efficiently with reactive proxies created by {@link proxy}.
 *
 * - **Minimizes Updates:** When copying between objects/arrays (proxied or not), if a nested object
 *   exists in `dst` with the same constructor as the corresponding object in `src`, `copy`
 *   will recursively copy properties into the existing `dst` object instead of replacing it.
 *   This minimizes change notifications for reactive (proxied) destinations.
 * - **Fast with Proxies:** When copying to/from proxied objects, `copy` uses Aberdeen internals
 *   to speed things up (compared to a non-Aberdeen-aware deep copy).
 *
 * @param dst - The destination object/array/Map (proxied or unproxied).
 * @param src - The source object/array/Map (proxied or unproxied). It won't be modified.
 * @template T - The type of the objects being copied.
 * @returns `true` if any changes were made to `dst`, or `false` if not.
 * @throws Error if attempting to copy an array into a non-array or vice versa.
 *
 * @example Basic Copy
 * ```typescript
 * const $source = A.proxy({ a: 1, b: { c: 2 } });
 * const $dest = A.proxy({ b: { d: 3 } });
 * A.copy($dest, $source);
 * console.log($dest); // proxy({ a: 1, b: { c: 2 } })
 * A.copy($dest, 'b', { e: 4 });
 * console.log($dest); // proxy({ a: 1, b: { e: 4 } })
 * ```
 */
export declare function copy<T extends object>(dst: T, src: T): boolean;
/**
 * Like above, but copies `src` into `dst[dstKey]`. This is useful if you're unsure if dst[dstKey]
 * already exists (as the right type of object) or if you don't want to subscribe to dst[dstKey].
 *
 * @param dstKey - Optional key in `dst` to copy into.
 */
export declare function copy<T extends object>(dst: T, dstKey: keyof T, src: T[typeof dstKey]): boolean;
/**
 * Like {@link copy}, but uses merge semantics. Properties in `dst` not present in `src` are kept.
 * `null`/`undefined` in `src` delete properties in `dst`.
 *
 * @example Basic merge
 * ```typescript
 * const source = { b: { c: 99 }, d: undefined }; // d: undefined will delete
 * const $dest = A.proxy({ a: 1, b: { x: 5 }, d: 4 });
 * A.merge($dest, source);
 * A.merge($dest, 'b', { y: 6 }); // merge into $dest.b
 * A.merge($dest, 'c', { z: 7 }); // $dest.c doesn't exist yet, so it will just be assigned
 * console.log($dest); // proxy({ a: 1, b: { c: 99, x: 5, y: 6 }, c: { z: 7 } })
 * ```
 *
 */
export declare function merge<T extends object>(dst: T, value: Partial<T>): boolean;
export declare function merge<T extends object>(dst: T, dstKey: keyof T, value: Partial<T[typeof dstKey]>): boolean;
/**
 * A symbol that controls how Aberdeen handles an object in copy operations and proxy wrapping.
 *
 * The **presence** of this symbol (regardless of its value) prevents deep-copying: the object is
 * stored and passed by reference in {@link clone} and {@link copy}.
 *
 * The **value** of the symbol controls proxy wrapping when the object is read from reactive state:
 * - **Truthy** (e.g. `true`): the object is fully opaque — it is not wrapped in a proxy, so its
 *   properties are not observable. Use this for objects that break when proxied (e.g. class instances
 *   with internal slots, Promises) or that must be invisible to Aberdeen's reactive system.
 * - **Falsy** (e.g. `false`): the object is still wrapped in a proxy, so reads on its properties
 *   create reactive dependencies as normal — only deep-copying is suppressed.
 */
export declare const OPAQUE: unique symbol;
/**
 * Use {@link OPAQUE} instead. This is an alias kept for backward compatibility.
 *
 * @deprecated
 */
export declare const NO_COPY: symbol;
/**
 * A reactive object containing CSS variable definitions.
 *
 * Any property you assign to `cssVars` becomes available as a CSS custom property throughout your application.
 *
 * Use {@link setSpacingCssVars} to optionally initialize `cssVars[1]` through `cssVars[12]` with an exponential spacing scale.
 *
 * When you reference a CSS variable in Aberdeen using the `$` prefix (e.g., `$primary`), it automatically resolves to `var(--primary)`.
 * For numeric keys (which can't be used directly as CSS custom property names), Aberdeen prefixes them with `m` (e.g., `$3` becomes `var(--m3)`).
 *
 * When you add the first property to cssVars, Aberdeen automatically creates a reactive `<style>` tag in `<head>`
 * containing the `:root` CSS custom property declarations. The style tag is automatically removed if cssVars becomes empty.
 *
 * @example
 * ```javascript
 * import A from 'aberdeen';
 *
 * // Optionally initialize spacing scale
 * A.setSpacingCssVars(); // Uses defaults: base=1, unit='rem'
 *
 * // Define custom colors - style tag is automatically created
 * A.cssVars.primary = '#3b82f6';
 * A.cssVars.danger = '#ef4444';
 *
 * // Use in elements with the $ prefix
 * A('button bg:$primary fg:white #I'm a primary button');
 *
 * // Use spacing (if setSpacingCssVars() was called)
 * A('hr mt:$3'); // Sets margin-top to var(--m3)
 * ```
 */
export declare const cssVars: Record<string, string>;
/**
 * Initializes `cssVars[0]` through `cssVars[12]` with an exponential spacing scale.
 *
 * The scale is calculated as `2^(n-3) * base`, providing values from `0.25 * base` to `512 * base`.
 *
 * @param base - The base size for the spacing scale that will apply to `cssVars[3]`. Every step up the scale will double this, while every step down will halve it. Defaults to 1.
 * @param unit - The CSS unit to use, like 'rem', 'em', or 'px'. Defaults to 'rem'.
 *
 * @example
 * ```javascript
 * import A from 'aberdeen';
 * // Use default scale (0.25rem to 512rem)
 * A.setSpacingCssVars();
 *
 * // Use custom base size
 * A.setSpacingCssVars(16, 'px'); // 4px to 8192px
 *
 * // Use em units
 * A.setSpacingCssVars(1, 'em'); // 0.25em to 512em
 *
 * // Show the last generated spacing values
 * A.onEach(A.cssVars, (value, key) => {
 * 	A(`div #${key} → ${value}`)
 * }, (value, key) => parseInt(key)); // Numeric sort
 * ```
 */
export declare function setSpacingCssVars(base?: number, unit?: string): void;
/**
 * Returns whether the user's browser prefers a dark color scheme.
 *
 * This function is reactive - scopes that call it will re-execute when the
 * browser's color scheme preference changes (via the `prefers-color-scheme` media query).
 *
 * Use this in combination with {@link A | A} and {@link cssVars} to implement theme switching:
 *
 * @returns `true` if the browser prefers dark mode, `false` if it prefers light mode.
 *
 * @example
 * ```javascript
 * import A from 'aberdeen';
 *
 * // Reactively set colors based on browser preference
 * A(() => {
 *   A.cssVars.bg = A.darkMode() ? '#1a1a1a' : '#ffffff';
 *   A.cssVars.fg = A.darkMode() ? '#e5e5e5' : '#000000';
 * });
 *
 * A('div bg:$bg fg:$fg p:1rem #Colors change based on system dark mode preference');
 * ```
 */
export declare function darkMode(): boolean;
/**
 * Clone an (optionally proxied) object or array.
 *
 * @param src The object or array to clone. If it is proxied, `clone` will subscribe to any changes to the (nested) data structure.
 * @template T - The type of the objects being copied.
 * @returns A new unproxied array or object (of the same type as `src`), containing a deep copy of `src`.
 */
export declare function clone<T extends object>(src: T): T;
/**
 * Creates a reactive reference (`{ value: T }`-like object) to a specific value
 * within a proxied object or array.
 *
 * This is primarily used for the `bind` property in {@link A | A} to create two-way data bindings
 * with form elements, and for passing a reactive property to any of the {@link A | A} key-value pairs.
 *
 * Reading `ref.value` accesses the property from the underlying proxy (and subscribes the current scope).
 * Assigning to `ref.value` updates the property in the underlying proxy (triggering reactive updates).
 *
 * @param target - The reactive proxy (created by {@link proxy}) containing the target property.
 * @param index - The key (for objects) or index (for arrays) of the property to reference.
 * @returns A reference object with a `value` property linked to the specified proxy property.
 *
 * @example
 * ```javascript
 * const $formData = A.proxy({ color: 'orange', velocity: 42 });
 *
 * // Usage with `bind`
 * A('input type=text bind=', A.ref($formData, 'color'));
 *
 * // Usage as a dynamic property, causes a TextNode with just the name to be created and live-updated
 * A('p text="Selected color: " text=', A.ref($formData, 'color'), 'color:', A.ref($formData, 'color'));
 *
 * // Changes are actually stored in $formData - this causes logs like `{color: "Blue", velocity 42}`
 * A(() => console.log($formData))
 * ```
 */
export declare function ref<T extends TargetType, K extends keyof T>(target: T, index: K): ValueRef<T[K]>;
/**
 * Make the `create` and `destroy` special properties no-ops.
 *
 * This is useful from within automated testing environments, where the transitioning
 * new and lingering old elements may make writing reliable selectors difficult.
 *
 * As this is only intended for testing, there's no way to re-enable the special properties
 * once disabled.
 */
export declare function disableCreateDestroy(): void;
/**
 * The core function for building reactive user interfaces in Aberdeen. It creates and inserts new DOM elements
 * and sets attributes/properties/event listeners on DOM elements. It does so in a reactive way, meaning that
 * changes will be (mostly) undone when the current *scope* is destroyed or will be re-execute.
 *
 * @param {...(string | function | object | false | undefined | null)} args - Any number of arguments can be given. How they're interpreted depends on their types:
 *
 * ### String arguments
 * Strings can be used to create and insert new elements, set classnames for the *current* element, and add text to the current element.
 * The format of a string is: (**tag** | `.` **class** | **key**[=:]**val** | **key**[=:]"**val containing spaces**")* ('#' **text** | **key**[=:])?
 *
 * So a string may consist of any number of...
 * - **tag** elements, like `h1` or `div`. These elements are created, added to the *current* element, and become the new *current* element for the rest of this `A` function execution.
 * - CSS classes prefixed by `.` characters. These classes will be added to the *current* element. Optionally, CSS classes can be appended to a **tag** without a space. So both `div.myclass` and `div .myclass` are valid and do the same thing.
 * - Property key/value pairs, like `type=password`, `placeholder="Your name"` or `data-id=123`. When the value contains spaces, it needs to be quoted with either "double quotes", 'single quotes' or \`backticks\`. Quotes within quoted values cannot be escaped (see the next rule for a solution). Key/value pairs will be handled according to *Property rules* below, but with the caveat that values can only be strings.
 * - CSS key/value pairs using two syntaxes:
 *   - **Short form** `key:value` (no space after colon): The value ends at the next whitespace. Example: `m:$3 bg:red r:8px`
 *   - **Long form** `key: value;` (space after colon): The value continues until a semicolon. Example: `box-shadow: 2px 0 6px black; transition: all 0.3s ease;`
 *
 *   Both forms support CSS shortcuts (see below). You can mix them: `m:$3 box-shadow: 0 2px 4px rgba(0,0,0,0.2); bg:$cardBg`
 * The elements must be separated by spaces, except before a `.cssClass` if it is preceded by either **tag** or another CSS class.
 *
 * And a string may end in...
 * - A '#' followed by text, which will be added as a `TextNode` to the *current* element. The text ranges til the end of the string, and may contain any characters, including spaces and quotes.
 * - A key followed by an '=' character, in which case the value is expected as a separate argument. The key/value pair is set according to the *Property rules* below. This is useful when the value is not a string or contains spaces or user data. Example: `A('button text="Click me" click=', () => alert('Clicked!'))` or `A('input.value=', someUserData, "placeholder=", "Type your stuff")`. In case the value is a proxied object, its `.value` property will be applied reactively without needing to rerender the parent scope.
 * - A key followed by a ':' character (with no value), in which case the value is expected as a separate argument. The value is treated as a CSS value to be set inline on the *current* element. Example: `A('div margin-top:', someValueInPx)`. In case the value is a proxied object, its `.value` property will be applied reactively without needing to rerender the parent scope.
 *
 * ### Function arguments
 * When a function (without arguments nor a return value) is passed in, it will be reactively executed in its own observer scope, preserving the *current* element. So any `A()` invocations within this function will add child elements to or set properties on that element. If the function reads observable data, and that data is changed later on, the function we re-execute (after side effects, such as DOM modifications through `A`, have been cleaned - see also {@link clean}).
 *
 * ### Object arguments
 * When an object is passed in, its key-value pairs are used to modify the *current* element according to the *Property rules* below, *unless* the key starts with a `$` character, in which case that character is stripped of and the key/value pair is treated as a CSS property, subject to the *CSS shortcuts* below. In case a value is a proxied object, its `.value` property will be applied reactively without needing to rerender the parent scope. In most cases, the string notation (`key=` and `key:`) is preferred over this object notation, for readability.
 *
 * ### DOM node arguments
 * When a DOM Node (Element or TextNode) is passed in, it is added as a child to the *current* element. If the Node is an Element, it becomes the new *current* element for the rest of this `A` function execution.
 *
 * ### Property rules
 * - **Attribute:** The common case is setting the value as an HTML attribute named key. For example `A('input placeholder=Name')` results in `<input placeholder="Name">`.
 * - **Event listener:** If the value is a `function` it is set as an event listener for the event with the name given by the key. For example: A('button text=Press! click=', () => alert('Clicked!'))`. The event listener will be removed when the current scope is destroyed.
 * - **DOM property:** When the value is a boolean, or the key is `"value"` or `"selectedIndex"`, it is set on the `current` element as a DOM property instead of an HTML attribute. For example `A('checked=', true)` would do `el.checked = true` for the *current* element.
 * - **Conditional CSS class:** If the key starts with a `.` character, its either added to or removed from the *current* element as a CSS class, based on the truthiness of the value. So `A('.hidden=', isHidden)` would toggle the `hidden` CSS class. This only works if the `=` is the last character of the string, and the next argument is the value. Its common for the value to be a proxied object, in which case its `.value` is reactively applied without needing to rerender the parent scope.
 * - **Create transition:** When the key is `"create"`, the value will be added as a CSS class to the *current* element immediately, and then removed right after the browser has finished doing a layout pass. This behavior only triggers when the scope setting the `create` is the top-level scope being (re-)run. This allows for creation transitions, without triggering the transitions for deeply nested elements being drawn as part of a larger component. The string may also contain multiple dot-separated CSS classes, such as `.fade.grow`. The initial dot is optional. Alternatively, to allow for more complex transitions, the value may be a function that receives the `HTMLElement` being created as its only argument. It is *only* called if this is the top-level element being created in this scope run. See `transitions.ts` in the Aberdeen source code for some examples.
 * - **Destroy transition:** When the key is `"destroy"` the value will be used to apply a CSS transition if the *current* element is later on removed from the DOM and is the top-level element to be removed. This happens as follows: the value string is added as a CSS class to the element, allowing for a deletion transition, and the element is actually removed from the DOM once the transitions/animations this started (anywhere in its subtree) have finished — immediately if there are none, and after at most 3 seconds in any case. The string may also contain multiple dot-separated CSS classes, such as `.fade.shrink`. The initial dot is optional. Alternatively, to allow for more complex transitions, the value may be a function that receives the `HTMLElement` to be removed from the DOM as its only argument. This function may perform any transitions and is then itself responsible for eventually removing the element from the DOM. See `transitions.ts` in the Aberdeen source code for some examples.
 * - **Two-way data binding:** When the key is `"bind"` a two-way binding between the `.value` property of the given proxied object, and the *current* input element (`<input>`, `<select>` or `<textarea>`) is created. This is often used together with {@link ref}, in order to use properties other than `.value`.
 * - **Text:**: If the key is `"text"`, the value will be appended as a `TextNode` to the *current* element. The same can also be done with the `#` syntax in string arguments, though `text=` allows additional properties to come after in the same string: `A('button text=Hello click=', alert)`.
 * - **Unsafe HTML:** When the key is `"html"`, the value will be added as HTML to the *current* element. This should only be used in exceptional situations. Beware of XSS! Never use this with untrusted user data.
 * - **Rich text:** When the key is `"rich"`, the value is parsed as simple markdown-like syntax and rendered as inline elements. Supports `*italic*`, `**bold**`, `` `code` ``, and `[link text](/path)`. All text content is safely escaped, making it suitable for user data (though links should be validated if untrusted). Example: `A('p rich="Click *here* for **more** info")`.
 *
 * ### CSS shortcuts
 * For conciseness, Aberdeen supports some CSS shortcuts when setting CSS properties.
 * | Shortcut | Expands to |
 * |----------|------------|
 * | `m`, `mt`, `mb`, `ml`, `mr` | `margin`, `margin-top`, `margin-bottom`, `margin-left`, `margin-right` |
 * | `mv`, `mh` | Vertical (top+bottom) or horizontal (left+right) margins |
 * | `p`, `pt`, `pb`, `pl`, `pr` | `padding`, `padding-top`, `padding-bottom`, `padding-left`, `padding-right` |
 * | `pv`, `ph` | Vertical or horizontal padding |
 * | `w`, `h` | `width`, `height` |
 * | `bg` | `background` |
 * | `fg` | `color` |
 * | `r` | `border-radius` |
 *
 * Also, when the value is a string starting with `$`, it is treated as a reference to a CSS variable, expanding to `var(--variableName)`. For numeric variable names (which can't be used directly as CSS custom property names), Aberdeen prefixes them with `m`, so `$3` expands to `var(--m3)`. This is primarily intended for use with {@link setSpacingCssVars}, which initializes spacing variables named `0` through `12` with an exponential spacing scale.
 *
 * To *set* a CSS custom property inline on an element, use a `--name` or (symmetrically with the `$`-reference syntax above) a `$name` key. For example `A('div --primary:red')` and `A('div $primary:red')` both set `--primary` to `red`.
 *
 * @returns The most inner DOM element that was created (not counting text nodes nor elements created by content functions), or the current element if no new element was created. You should normally not need to use the return value - use this function's DOM manipulation abilities instead. One valid use case is when integrating with non-Aberdeen code that requires a reference to a DOM element.
 *
 * @example Create Element
 * ```typescript
 * A('button.secondary.outline text=Submit color:red disabled=', false, 'click=', () => console.log('Clicked!'));
 * ```
 *
 * We want to set `disabled` as a property instead of an attribute, so we must use the `key=` syntax in order to provide
 * `false` as a boolean instead of a string.
 *
 * @example Create Nested Elements
 * ```typescript
 * let inputElement: Element = A('label text="Click me" input type=checkbox');
 * // You should usually not touch raw DOM elements, unless when integrating
 * // with non-Aberdeen code.
 * console.log('DOM element:', inputElement);
 * ```
 *
 * @example Content Functions & Reactive Scope
 * ```typescript
 * const $state = A.proxy({ count: 0 });
 * A('div', () => { // Outer element
 *   // This scope re-renders when $state.count changes
 *   A(`p#Count is ${$state.count}`);
 *   A('button text=Increment click=', () => $state.count++);
 * });
 * ```
 *
 * @example Two-way Binding
 * ```typescript
 * const $user = A.proxy({ name: '' });
 * A('input placeholder=Name bind=', A.ref($user, 'name'));
 * A('h3', () => { // Reactive scope
 *   A(`#Hello ${$user.name || 'stranger'}`);
 * });
 * ```
 *
 * @example Conditional Rendering
 * ```typescript
 * const $show = A.proxy(false);
 * A('button click=', () => $show.value = !$show.value, () => A($show.value ? '#Hide' : '#Show'));
 * A(() => { // Reactive scope
 *   if ($show.value) {
 *     A('p#Details are visible!');
 *   }
 * });
 * ```
 *
 * @example Proxied objects as values
 * ```typescript
 * const $myColor = A.proxy('red');
 * A('p text="The color is " text=', $myColor, 'click=', () => $myColor.value = 'yellow')
 * // Clicking the text will cause it to change color without recreating the <p> itself
 * ```
 * This is often used together with {@link ref}, in order to use properties other than `.value`.
 */
export declare function A(...args: any[]): undefined | Element;
/**
 * Inserts CSS rules into the document, scoping them with a unique class name.
 *
 * The `style` parameter can be either:
 * - A **concise style string** (for rules applying to the root class).
 * - An **object** where keys are selectors (with `&` representing the root class)
 *   and values are concise style strings or nested objects. When the key does not contain `&`,
 *   it is treated as a descendant selector. So `{p: "color:red"}` becomes `".AbdStlX p { color: red; }"` with `AbdStlX` being the generated class name.
 *
 * ### Concise Style Strings
 *
 * Concise style strings use two syntaxes (same as inline CSS in {@link A | A}):
 * - **Short form** `key:value` (no space after colon): The value ends at the next whitespace.
 *   Example: `'m:$3 bg:red r:8px'`
 * - **Long form** `key: value;` (space after colon): The value continues until a semicolon.
 *   Example: `'box-shadow: 2px 0 6px black; transition: all 0.3s ease;'`
 *
 * Both forms can be mixed: `'m:$3 box-shadow: 0 2px 4px rgba(0,0,0,0.2); bg:$cardBg'`
 *
 * Supports the same CSS shortcuts as {@link A | A} and CSS variable references with `$` (e.g., `$primary`, `$3`).
 *
 * CSS is inserted into the <head> in an order relative to other insert(Global)Css items that is consistent
 * based on when the containing Aberdeen scope was first defined. This allows changing styles without changing
 * order-based precedence.
 *
 * @param style - A concise style string or a style object.
 * @returns The unique class name prefix used for scoping (e.g., `.AbdStl1`).
 *          Use this prefix with {@link A | A} to apply the styles.
 *
 * @example Basic Usage with Shortcuts and CSS Variables
 * ```typescript
 * const cardClass = A.insertCss({
 *   '&': 'bg:white p:$4 r:8px transition: background-color 0.3s;',
 *   '&:hover': 'bg:#f5f5f5',
 * });
 *
 * A('section', cardClass, () => {
 *   A('p#Card content');
 * });
 * ```
 *
 * @example Nested Selectors and Media Queries
 * ```typescript
 * const formClass = A.insertCss({
 *   '&': 'bg:#0004 p:$3 r:$2',
 *   button: {
 *     '&': 'bg:$primary fg:white p:$2 r:4px cursor:pointer',
 *     '&:hover': 'bg:$primaryHover',
 *     '&:disabled': 'bg:#ccc cursor:not-allowed',
 *     '.icon': 'display:inline-block mr:$1',
 *     '@media (max-width: 600px)': 'p:$1 font-size:14px'
 *   }
 * });
 *
 * A('form', formClass, () => {
 *   A('button', () => {
 *     A('span.icon text=🔥');
 *     A('#Click Me');
 *   });
 * });
 * ```
 *
 * @example Complex CSS Values
 * ```typescript
 * const badge = A.insertCss({
 *   '&::before': 'content: "★"; color:gold mr:$1',
 *   '&': 'position:relative box-shadow: 0 2px 8px rgba(0,0,0,0.15);'
 * });
 *
 * A(badge + ' span#Product Name');
 * ```
 */
export declare function insertCss(style: string | object): string;
/**
 * Inserts CSS rules globally (unscoped).
 *
 * Works exactly like {@link insertCss}, but without prefixing selectors with a unique class name.
 * This is useful for global resets, base styles, or styles that need to apply to the entire document.
 *
 * Accepts the same concise style string syntax and CSS shortcuts as {@link insertCss}.
 * See {@link insertCss} for detailed documentation on syntax and shortcuts.
 *
 * @param style - Object with selectors as keys and concise CSS strings as values.
 *
 * CSS is inserted into the <head> in an order relative to other insert(Global)Css items that is consistent
 * based on when the containing Aberdeen scope was first defined. This allows changing styles without changing
 * order-based precedence.
 *
 * @example Global Reset and Base Styles
 * ```typescript
 * // Set up global styles using CSS shortcuts
 * A.insertGlobalCss({
 *   "*": "m:0 p:0 box-sizing:border-box",
 *   "body": "font-family: system-ui, sans-serif; m:0 p:$3 bg:#434 fg:#d0dafa",
 *   "a": "text-decoration:none fg:#57f",
 *   "a:hover": "text-decoration:underline",
 *   "code": "font-family:monospace bg:#222 fg:#afc p:4px r:3px"
 * });
 *
 * A('h2#Title without margins');
 * A('a#This is a link');
 * A('code#const x = 42;');
 * ```
 *
 * @example Responsive Global Styles
 * ```typescript
 * A.insertGlobalCss({
 *   "html": "font-size:16px",
 *   "body": "line-height:1.6",
 *   "h1, h2, h3": "font-weight:600 mt:$4 mb:$2",
 *   "@media (max-width: 768px)": {
 *     "html": "font-size:14px",
 *     "body": "p:$2"
 *   },
 *   "@media (prefers-color-scheme: dark)": {
 *     "body": "bg:#1a1a1a fg:#e5e5e5",
 *     "code": "bg:#2a2a2a"
 *   }
 * });
 * ```
 * At-rules such as `@media` and `@keyframes` should use nested objects. For keyframes,
 * the step selectors (`0%`, `50%`, `100%`, etc.) become the nested keys and each value
 * should be a concise CSS declaration string.
 *
 * @example Animation Keyframes
 * ```typescript
 * A.insertGlobalCss({
 *   "@keyframes connection-pulse": {
 *     "0%": "box-shadow: inset 0 0 0 0 rgba(255, 70, 70, 0.4);",
 *     "50%": "box-shadow: inset 0 0 0 6px rgba(255, 70, 70, 0.08);",
 *     "100%": "box-shadow: inset 0 0 0 0 rgba(255, 70, 70, 0.4);"
 *   }
 * });
 * ```
 */
export declare function insertGlobalCss(style: object): void;
/**
 * Sets a custom error handler function for errors that occur asynchronously
 * within reactive scopes (e.g., during updates triggered by proxy changes in
 * {@link derive} or {@link A | A} render functions).
 *
 * The default handler logs the error to `console.error` and adds a simple
 * 'Error' message div to the DOM at the location where the error occurred (if possible).
 *
 * Your handler can provide custom logging, UI feedback, or suppress the default
 * error message.
 *
 * @param handler - A function that accepts the `Error` object.
 *   - Return `false` to prevent adding an error message to the DOM.
 *   - Return `true` or `undefined` (or throw) to allow the error messages to be added to the DOM.
 *
 * @example Custom Logging and Suppressing Default Message
 * ```typescript
 * A.setErrorHandler(error => {
 *   console.warn('Aberdeen render error:', error.message);
 *   // Log to error reporting service
 *   // myErrorReporter.log(error);
 *
 *   try {
 *     // Attempt to show a custom message in the UI
 *     A('div#Oops, something went wrong!', errorClass);
 *   } catch (e) {
 *     // Ignore errors during error handling itself
 *   }
 *
 *   return false; // Suppress default console log and DOM error message
 * });
 *
 * // Styling for our custom error message
 * const errorClass = A.insertCss('background-color:#e31f00 display:inline-block color:white r:3px padding: 2px 4px;');
 *
 * // Cause an error within a render scope.
 * A('div.box', () => {
 *   // Will cause our error handler to insert an error message within the box
 *   noSuchFunction();
 * })
 * ```
 */
export declare function setErrorHandler(handler?: (error: Error) => boolean | undefined): void;
/**
 * Registers a cleanup function to be executed just before the current reactive scope
 * is destroyed or redraws.
 *
 * This is useful for releasing resources, removing manual event listeners, or cleaning up
 * side effects associated with the scope. Cleaners are run in reverse order of registration.
 *
 * Scopes are created by functions like {@link derive}, {@link mount}, {@link A | A} (when given a render function),
 * and internally by constructs like {@link onEach}.
 *
 * @param cleaner - The function to execute during cleanup.
 *
 * @example Maintaing a sum for a changing array
 * ```typescript
 * const $numbers = A.proxy([3, 5, 10]);
 * let $sum = A.proxy(0);
 *
 * // Show the array items and maintain the sum
 * A.onEach($numbers, (item, index) => {
 *     A(`code#${index}→${item}`);
 *     // We'll update $sum.value using peek, as += first does a read, but
 *     // we don't want to subscribe.
 *     A.peek(() => $sum.value += item);
 *     // Clean gets called before each rerun for a certain item index
 *     // No need for peek here, as the clean code doesn't run in an
 *     // observer scope.
 *     A.clean(() => $sum.value -= item);
 * })
 *
 * // Show the sum
 * A('h1 text=', $sum);
 *
 * // Make random changes to the array
 * const rnd = () => 0|(Math.random()*20);
 * setInterval(() => $numbers[rnd()] = rnd(), 1000);
 * ```
 */
export declare function clean(cleaner: () => void): void;
/**
 * Creates a reactive scope that automatically re-executes the provided function
 * whenever any proxied data (created by {@link proxy}) read during its last execution changes, storing
 * its return value in an observable.
 *
 * Updates are batched and run asynchronously shortly after the changes occur.
 * Use {@link clean} to register cleanup logic for the scope.
 * Use {@link peek} or {@link unproxy} within the function to read proxied data without subscribing to it.
 *
 * @param func - The function to execute reactively. Any DOM manipulations should typically
 *   be done using {@link A | A} within this function. Its return value will be made available as an
 *   observable returned by the `derive()` function.
 * @returns An observable object, with its `value` property containing whatever the last run of `func` returned.
 *
 * @example Observation creating UI components
 * ```typescript
 * const $data = A.proxy({ user: 'Frank', notifications: 42 });
 *
 * A('main', () => {
 *   console.log('Welcome');
 *   A('h3#Welcome, ' + $data.user); // Reactive text
 *
 *   A.derive(() => {
 *     // When $data.notifications changes, only this inner scope reruns,
 *     // leaving the `<p>Welcome, ..</p>` untouched.
 *     console.log('Notifications');
 *     A('code.notification-badge text=', $data.notifications);
 *     A('a text=Notify! click=', () => $data.notifications++);
 *   });
 * });
 * ```
 *
 * ***Note*** that the above could just as easily be done using `A(func)` instead of `derive(func)`.
 *
 * @example Observation with return value
 * ```typescript
 * const $counter = A.proxy(0);
 * setInterval(() => $counter.value++, 1000);
 * const $double = A.derive(() => $counter.value * 2);
 *
 * A('h3', () => {
 *     A(`#counter=${$counter.value} double=${$double.value}`);
 * })
 * ```
 *
 * @overload
 * @param func Func without a return value.
 */
export declare function derive<T>(func: () => T): ValueRef<T>;
/**
 * Attaches a reactive Aberdeen UI fragment to an existing DOM element. Without the use of
 * this function, {@link A | A} will assume `document.body` as its root.
 *
 * It creates a top-level reactive scope associated with the `parentElement`. The provided
 * function `func` is executed immediately within this scope. Any proxied data read by `func`
 * will cause it to re-execute when the data changes, updating the DOM elements created within it.
 *
 * Calls to {@link A | A} inside `func` will append nodes to `parentElement`.
 * You can nest {@link derive} or other {@link A | A} scopes within `func`.
 * Use {@link unmountAll} to clean up all mounted scopes and their DOM nodes.
 *
 * Mounting scopes happens reactively, meaning that if this function is called from within another
 * ({@link derive} or {@link A | A} or {@link mount}) scope that gets cleaned up, so will the mount.
 *
 * @param parentElement - The native DOM `Element` to which the UI fragment will be appended.
 * @param func - The function that defines the UI fragment, typically containing calls to {@link A | A}.
 *
 * @example Basic Mount
 * ```javascript
 * // Create a pre-existing DOM structure (without Aberdeen)
 * document.body.innerHTML = `<h3>Static content <span id="title-extra"></span></h3><div class="box" id="app-root"></div>`;
 *
 * import A from 'aberdeen';
 *
 * const $runTime = A.proxy(0);
 * setInterval(() => $runTime.value++, 1000);
 *
 * A.mount(document.getElementById('app-root'), () => {
 *   A('h4#Aberdeen App');
 *   A(`p#Run time: ${$runTime.value}s`);
 *   // Conditionally render some content somewhere else in the static page
 *   if ($runTime.value&1) {
 *     A.mount(document.getElementById('title-extra'), () =>
 *       A(`i#(${$runTime.value}s)`)
 *     );
 *   }
 * });
 * ```
 *
 * Note how the inner mount behaves reactively as well, automatically unmounting when it's parent observer scope re-runs.
 */
export declare function mount(parentElement: Element, func: () => void): void;
/**
 * Removes all Aberdeen-managed DOM nodes and stops all active reactive scopes
 * (created by {@link mount}, {@link derive}, {@link A | A} with functions, etc.).
 *
 * This effectively cleans up the entire Aberdeen application state. Aside from in
 * automated tests, there should probably be little reason to call this function.
 */
export declare function unmountAll(): void;
/**
 * Executes a function or retrieves a value *without* creating subscriptions in the current reactive scope, and returns its result.
 *
 * This is useful when you need to access reactive data inside a reactive scope (like {@link A | A})
 * but do not want changes to that specific data to trigger a re-execute of the scope.
 *
 * Note: You may also use {@link unproxy} to get to the raw underlying data structure, which can be used to similar effect.
 *
 * @param target - Either a function to execute, or an object (which may also be an Array or a Map) to index.
 * @param key - Optional key/index to use when `target` is an object.
 * @returns The result of the function call, or the value at `target[key]` when `target` is an object or `target.get(key)` when it's a Map.
 *
 * @example Peeking within observer
 * ```typescript
 * const $data = A.proxy({ a: 1, b: 2 });
 * A(() => {
 *   // re-executes only when $data.a changes, because $data.b is peeked.
 *   const b = A.peek(() => $data.b);
 *   console.log(`A is ${$data.a}, B was ${b} when A changed.`);
 * });
 * $data.b = 3; // Does not trigger console.log
 * $data.a = 2; // Triggers console.log (logs "A is 2, B was 3 when A changed.")
 * ```
 *
 */
export declare function peek<T extends object, K extends keyof T>(target: T, key: K): T[K];
export declare function peek<K, V>(target: Map<K, V>, key: K): V | undefined;
export declare function peek<T>(target: T[], key: number): T | undefined;
export declare function peek<T>(target: () => T): T;
/** When using a Map as `source`. */
export declare function map<K, IN, OUT>(source: Map<K, IN>, func: (value: IN, key: K) => undefined | OUT): Map<K, OUT>;
/** When using an array as `source`. */
export declare function map<IN, OUT>(source: Array<IN>, func: (value: IN, index: number) => undefined | OUT): Array<OUT>;
/** When using an object as `source`. */
export declare function map<IN, const IN_KEY extends string | number | symbol, OUT>(source: Record<IN_KEY, IN>, func: (value: IN, index: KeyToString<IN_KEY>) => undefined | OUT): Record<string | symbol, OUT>;
/** When using an array as `source`. */
export declare function multiMap<IN, OUT extends {
    [key: string | symbol]: any;
}>(source: Array<IN>, func: (value: IN, index: number) => OUT | undefined): OUT;
/** When using an object as `source`. */
export declare function multiMap<K extends string | number | symbol, IN, OUT extends {
    [key: string | symbol]: any;
}>(source: Record<K, IN>, func: (value: IN, index: KeyToString<K>) => OUT | undefined): OUT;
/** When using a Map as `source`. */
export declare function multiMap<K, IN, OUT extends {
    [key: string | symbol]: any;
}>(source: Map<K, IN>, func: (value: IN, key: K) => OUT | undefined): OUT;
/** When using an object as `array`. */
export declare function partition<OUT_K extends string | number | symbol, IN_V>(source: IN_V[], func: (value: IN_V, key: number) => undefined | OUT_K | OUT_K[]): Record<OUT_K, Record<number, IN_V>>;
/** When using an object as `source`. */
export declare function partition<IN_K extends string | number | symbol, OUT_K extends string | number | symbol, IN_V>(source: Record<IN_K, IN_V>, func: (value: IN_V, key: IN_K) => undefined | OUT_K | OUT_K[]): Record<OUT_K, Record<IN_K, IN_V>>;
/** When using a Map as `source`. */
export declare function partition<IN_K extends string | number | symbol, OUT_K extends string | number | symbol, IN_V>(source: Map<IN_K, IN_V>, func: (value: IN_V, key: IN_K) => undefined | OUT_K | OUT_K[]): Record<OUT_K, Record<IN_K, IN_V>>;
/**
 * Renders a live, recursive dump of a proxied data structure (or any value)
 * into the DOM at the current {@link A | A} insertion point.
 *
 * Uses `<ul>` and `<li>` elements to display object properties and array items.
 * Updates reactively if the dumped data changes. Primarily intended for debugging purposes.
 *
 * @param data - The proxied data structure (or any value) to display.
 * @returns The original `data` argument, allowing for chaining.
 * @template T - The type of the data being dumped.
 *
 * @example Dumping reactive state
 * ```typescript
 * import A from 'aberdeen';
 *
 * const $state = A.proxy({
 *   user: { name: 'Frank', kids: 1 },
 *   items: ['a', 'b']
 * });
 *
 * A('h2#Live State Dump');
 * A.dump($state);
 *
 * // Change state later, the dump in the DOM will update
 * setTimeout(() => { $state.user.kids++; $state.items.push('c'); }, 2000);
 * ```
 */
export declare function dump<T>(data: T): T;
/**
 * When set on an object or its prototype chain, {@link dump} calls this as a render function
 * (with the object as `this`) instead of its default recursive rendering. If the value is not
 * a function, it's treated as a string to display.
 *
 * @example
 * ```typescript
 * class Color {
 *   constructor(public r: number, public g: number, public b: number) {}
 *   [CUSTOM_DUMP]() { A(`#rgb(${this.r}, ${this.g}, ${this.b})`); }
 * }
 * ```
 */
export declare const CUSTOM_DUMP: unique symbol;
/**
 * The main Aberdeen API. `A` is itself a callable function for building reactive DOM trees
 * (creating elements, setting attributes, adding content). All other Aberdeen functions and
 * values are available as properties on `A`.
 *
 * @example Basic usage
 * ```typescript
 * import A from 'aberdeen';
 *
 * const $state = A.proxy({ count: 0 });
 * A('div', () => {
 *   A(`p#Count: ${$state.count}`);
 *   A('button text=+ click=', () => $state.count++);
 * });
 * ```
 */
declare const _default: typeof A & {
    /** {@inheritDoc clean} */ clean: typeof clean;
    /** {@inheritDoc clone} */ clone: typeof clone;
    /** {@inheritDoc copy} */ copy: typeof copy;
    /** {@inheritDoc count} */ count: typeof count;
    /** {@inheritDoc cssVars} */ cssVars: Record<string, string>;
    /** {@inheritDoc CUSTOM_DUMP} */ CUSTOM_DUMP: symbol;
    /** {@inheritDoc darkMode} */ darkMode: typeof darkMode;
    /** {@inheritDoc derive} */ derive: typeof derive;
    /** {@inheritDoc disableCreateDestroy} */ disableCreateDestroy: typeof disableCreateDestroy;
    /** {@inheritDoc dump} */ dump: typeof dump;
    /** {@inheritDoc freeze} */ freeze: typeof freeze;
    /** {@inheritDoc insertCss} */ insertCss: typeof insertCss;
    /** {@inheritDoc insertGlobalCss} */ insertGlobalCss: typeof insertGlobalCss;
    /** {@inheritDoc invertString} */ invertString: typeof invertString;
    /** {@inheritDoc isEmpty} */ isEmpty: typeof isEmpty;
    /** {@inheritDoc map} */ map: typeof map;
    /** {@inheritDoc merge} */ merge: typeof merge;
    /** {@inheritDoc mount} */ mount: typeof mount;
    /** {@inheritDoc multiMap} */ multiMap: typeof multiMap;
    /** {@inheritDoc OPAQUE} */ OPAQUE: symbol;
    /** {@inheritDoc NO_COPY} */ NO_COPY: symbol;
    /** {@inheritDoc onEach} */ onEach: typeof onEach;
    /** {@inheritDoc partition} */ partition: typeof partition;
    /** {@inheritDoc peek} */ peek: typeof peek;
    /** {@inheritDoc proxy} */ proxy: typeof proxy;
    /** {@inheritDoc ref} */ ref: typeof ref;
    /** {@inheritDoc runQueue} */ runQueue: typeof runQueue;
    /** {@inheritDoc setErrorHandler} */ setErrorHandler: typeof setErrorHandler;
    /** {@inheritDoc setSpacingCssVars} */ setSpacingCssVars: typeof setSpacingCssVars;
    /** {@inheritDoc unmountAll} */ unmountAll: typeof unmountAll;
    /** {@inheritDoc unproxy} */ unproxy: typeof unproxy;
};
export default _default;