import type { ItemTemplate } from "lit-html/directives/repeat.js";
import { type RenderKeyArg } from "../../Directives/arrayRender";
import { type AtomType } from "./atom";
/** Input row: object with optional key field (default `id`). */
export type ListItemInput<T extends object = object, K extends string = "id"> = T & {
    [P in K]?: string;
};
/** Stored row: plain object with a required, readonly key field. */
export type ListRow<T extends object = object, K extends string = "id"> = Omit<T, K> & {
    readonly [P in K]: string;
};
/** Ensure each object has `keyName`; generate uuid when missing. Key is readonly. */
export declare function ensureListItemKey<T extends object, K extends string = "id">(item: ListItemInput<T, K>, keyName?: K): ListRow<T, K>;
/**
 * Build a keyed object array from primitives or objects.
 * Primitives become `{ [keyName]: uuid, value: item }` with a readonly key.
 * Objects get `keyName` stamped readonly when missing.
 *
 * @example
 * atom.list(createList(["a", "b"]))
 * atom.list(createList([{ name: "x" }]))
 */
export declare function createList<T, K extends string = "id">(items?: readonly T[], keyName?: K): Array<T extends object ? ListRow<T, K> : {
    value: T;
} & {
    readonly [P in K]: string;
}>;
export type ListAtomType<T extends object = object, K extends string = "id"> = Omit<AtomType<ListRow<T, K>[]>, "update" | "set"> & {
    (): ListRow<T, K>[];
    get(): ListRow<T, K>[];
    /** Property name used as the stable key (default `"id"`). */
    readonly keyName: K;
    /**
     * Replace the whole list (or map from previous rows).
     * Every item must be a plain object; missing keys are stamped.
     * Throws if any two rows share the same key.
     */
    setList(value: readonly ListItemInput<T, K>[] | ((prev: ListRow<T, K>[]) => readonly ListItemInput<T, K>[]), silently?: boolean): void;
    /** Append an object. Stamps `keyName` when missing. Returns the key. Throws on duplicate key. */
    add(item: ListItemInput<T, K>): string;
    /**
     * Delete by key or index.
     * Key lookup uses the first matching row (keys are required to be unique on write).
     */
    delete(keyOrIndex: string | number): ListAtomType<T, K>;
    /**
     * Return the row at `keyOrIndex`, or `undefined`.
     * Key lookup uses the first matching row. Does not notify.
     */
    getItem(keyOrIndex: string | number): ListRow<T, K> | undefined;
    /**
     * Whether a row exists at `keyOrIndex` (index in range, or key present).
     * Key lookup uses the first matching row. Does not notify.
     */
    has(keyOrIndex: string | number): boolean;
    /**
     * Move an item (by key or index) to `toIndex`.
     * `toIndex` is applied after removal (same as `atom.array.move`).
     * No-op if either side is out of range.
     */
    move(fromKeyOrIndex: string | number, toIndex: number): ListAtomType<T, K>;
    /**
     * Mutate one row by key/index in place, then notify via `set(get())`.
     * The key field is readonly — delete the item and `add` a new one to change identity.
     * Key lookup uses the first matching row. No-op (no notify) if missing.
     */
    updateItem(keyOrIndex: string | number, fn: (item: ListRow<T, K>) => void): ListAtomType<T, K>;
    /**
     * Mutate every row in place, then notify via `set(get())`.
     * Key fields are readonly.
     */
    updateAll(fn: (item: ListRow<T, K>, index: number) => void): ListAtomType<T, K>;
    deleteItems(pred: (item: ListRow<T, K>, index: number) => boolean): ListAtomType<T, K>;
    clear(): ListAtomType<T, K>;
    sort(compareFn?: (a: ListRow<T, K>, b: ListRow<T, K>) => number): ListRow<T, K>[];
    sortAndSet(compareFn?: (a: ListRow<T, K>, b: ListRow<T, K>) => number): ListAtomType<T, K>;
    forEach(fn: (item: ListRow<T, K>, index: number, arr: ListRow<T, K>[]) => void): void;
    render(template: ItemTemplate<ListRow<T, K>>, key?: RenderKeyArg<ListRow<T, K>>): unknown;
    /** `JSON.stringify` of the current row array. */
    toJSON(): string;
    readonly size: number;
};
/**
 * Ordered keyed list of **plain objects** (for dynamic UI lists).
 *
 * Keys (`id` by default, or custom `keyName`) are stamped **readonly** and must
 * be unique. To change an item's identity, `delete` it and `add` a new row.
 * Lookups by key (`getItem`, `has`, `delete`, `updateItem`) use the first match.
 *
 * Primitives are not allowed — use {@link createList} first:
 *
 * ```ts
 * atom.list(createList(["a", "b"]))
 * atom.list([{ name: "x" }])           // id auto-stamped (readonly)
 * atom.list([{ uuid: "1", name: "x" }], "uuid")
 * ```
 */
export declare function createListAtom<T extends object = object, K extends string = "id">(initial?: readonly ListItemInput<T, K>[], keyName?: K): ListAtomType<T, K>;
//# sourceMappingURL=createListAtom.d.ts.map