nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/QrCode.js

@@ -0,0 +1,463 @@
+/*
+ * A QR code encoder, QR Code Model 2 as ISO/IEC 18004 describes it, written by hand so that no package is needed: an
+ * authenticator app's otpauth:// address for a phone to scan, a link, any text. `QrCodeImage` draws it. Byte mode only:
+ * the text goes in as UTF-8, which is what readers take byte mode to be. Versions 1 to 40 (21 to 177 modules a side) at
+ * the four error correction levels; L, M, Q and H restore about 7%, 15%, 25% and 30% of a damaged code.
+ *
+ * The steps are the standard's own:
+ *   1. the data codewords: the mode, the byte count, the bytes, a terminator and pad codewords, in the smallest version
+ *      that holds them at the level asked;
+ *   2. the error correction: the data cut into the version's blocks, each followed by its Reed-Solomon codewords, then
+ *      interleaved one codeword from each block at a time;
+ *   3. the matrix: the function patterns (the finders and their separators, the timing and alignment patterns, the dark
+ *      module, the format and version information), then the codewords' bits in a zigzag around them;
+ *   4. the mask: all eight scored by the four penalty rules, and the lowest kept.
+ *
+ * Plain TypeScript that Node runs as it is (no enum, namespace or parameter properties), so that
+ * Project-Skills/Checks/qr-code-check.mjs can import this file and read every code back with an independent decoder
+ * (jsQR, a test-only oracle installed outside the repository: the check's header says how).
+ */
+/** The level's two bits in the format information. */
+const LEVEL_BITS = { L: 1, M: 0, Q: 3, H: 2 };
+/** Error correction codewords in each block, for versions 1 to 40 (ISO/IEC 18004 Table 9). */
+const ECC_PER_BLOCK = {
+    L: [7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    M: [10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+    Q: [13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    H: [17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+};
+/** The blocks a version's codewords are cut into, for versions 1 to 40 (Table 9). */
+const BLOCKS = {
+    L: [1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+    M: [1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+    Q: [1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+    H: [1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],
+};
+/** The rows (and the same columns) of the alignment patterns' centres, for versions 1 to 40 (Annex E). */
+const ALIGNMENT_CENTRES = [
+    [], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34],
+    [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50], [6, 30, 54], [6, 32, 58], [6, 34, 62],
+    [6, 26, 46, 66], [6, 26, 48, 70], [6, 26, 50, 74], [6, 30, 54, 78], [6, 30, 56, 82], [6, 30, 58, 86], [6, 34, 62, 90],
+    [6, 28, 50, 72, 94], [6, 26, 50, 74, 98], [6, 30, 54, 78, 102], [6, 28, 54, 80, 106], [6, 32, 58, 84, 110],
+    [6, 30, 58, 86, 114], [6, 34, 62, 90, 118],
+    [6, 26, 50, 74, 98, 122], [6, 30, 54, 78, 102, 126], [6, 26, 52, 78, 104, 130], [6, 30, 56, 82, 108, 134],
+    [6, 34, 60, 86, 112, 138], [6, 30, 58, 86, 114, 142], [6, 34, 62, 90, 118, 146],
+    [6, 30, 54, 78, 102, 126, 150], [6, 24, 50, 76, 102, 128, 154], [6, 28, 54, 80, 106, 132, 158],
+    [6, 32, 58, 84, 110, 136, 162], [6, 26, 54, 82, 110, 138, 166], [6, 30, 58, 86, 114, 142, 170],
+];
+/** Dark, light, dark, dark, dark, light, dark: a finder pattern's row, which penalty rule 3 looks for. */
+const FINDER_LIKE = [true, false, true, true, true, false, true];
+/**
+ * The text as a QR code at the level asked (M unless told), in the smallest version that holds it. Throws when the
+ * text is too long even for version 40: 2,953 bytes of UTF-8 at L, 2,331 at M, 1,663 at Q, 1,273 at H.
+ */
+export function encodeQr(text, level = "M") {
+    const bytes = new TextEncoder().encode(text);
+    const version = smallestVersion(bytes.length, level);
+    const codewords = interleave(dataCodewords(bytes, version, level), version, level);
+    const grid = functionPatterns(version);
+    placeCodewords(grid, codewords);
+    // The mask that leaves a reader the fewest look-alike patterns: each is scored on the finished code, its own format
+    // information included, and the first lowest wins.
+    let mask = 0;
+    let code = withMask(grid, level, 0);
+    let lowest = penalty(code);
+    for (let candidate = 1; candidate < 8; candidate++) {
+        const masked = withMask(grid, level, candidate);
+        const points = penalty(masked);
+        if (points < lowest) {
+            mask = candidate;
+            code = masked;
+            lowest = points;
+        }
+    }
+    const { size, dark } = code;
+    return {
+        version,
+        size,
+        level,
+        mask,
+        isDark: (x, y) => x >= 0 && y >= 0 && x < size && y < size && dark[y * size + x] === true,
+    };
+}
+/**
+ * The code as one SVG path in a square viewBox, with `border` light modules around it (4, the quiet zone the standard
+ * asks for). Each run of dark modules along a row is one rectangle.
+ */
+export function qrPath(code, border = 4) {
+    const runs = [];
+    for (let y = 0; y < code.size; y++) {
+        let x = 0;
+        while (x < code.size) {
+            if (!code.isDark(x, y)) {
+                x++;
+                continue;
+            }
+            const start = x;
+            while (x < code.size && code.isDark(x, y))
+                x++;
+            runs.push(`M${start + border} ${y + border}h${x - start}v1h-${x - start}z`);
+        }
+    }
+    const side = code.size + border * 2;
+    return { viewBox: `0 0 ${side} ${side}`, d: runs.join("") };
+}
+/** The smallest version whose data codewords hold the mode, the byte count and the bytes at this level. */
+function smallestVersion(byteCount, level) {
+    for (let version = 1; version <= 40; version++) {
+        if (4 + countBits(version) + byteCount * 8 <= dataCodewordCount(version, level) * 8)
+            return version;
+    }
+    const most = Math.floor((dataCodewordCount(40, level) * 8 - 4 - countBits(40)) / 8);
+    throw new Error(`The text is ${byteCount} bytes, more than a QR code holds at level ${level} (${most} bytes).`);
+}
+/** The bits of the byte count after the mode: 8 up to version 9, 16 from version 10. */
+function countBits(version) {
+    return version <= 9 ? 8 : 16;
+}
+/** A version's error correction at a level: how many blocks, and how many check codewords in each. */
+function blockLayout(version, level) {
+    const blocks = BLOCKS[level][version - 1];
+    const eccPerBlock = ECC_PER_BLOCK[level][version - 1];
+    if (blocks === undefined || eccPerBlock === undefined)
+        throw new Error(`There is no QR code version ${version}.`);
+    return { blocks, eccPerBlock };
+}
+function alignmentCentres(version) {
+    return ALIGNMENT_CENTRES[version - 1] ?? [];
+}
+/** All the codewords of a version: the modules its function patterns leave free, in whole bytes. */
+function totalCodewords(version) {
+    const size = version * 4 + 17;
+    const across = alignmentCentres(version).length;
+    let modules = size * size;
+    modules -= 3 * 8 * 8; // the three finders, each with its separator
+    modules -= 2 * 15 + 1; // the format information twice, and the dark module
+    modules -= 2 * (size - 16); // the timing patterns between the separators
+    if (across > 0) {
+        // Every alignment pattern but the three where the finders are; those on a timing pattern share 5 modules with it.
+        modules -= (across * across - 3) * 25 - 2 * (across - 2) * 5;
+    }
+    if (version >= 7)
+        modules -= 2 * 18; // the version information twice
+    return Math.floor(modules / 8);
+}
+function dataCodewordCount(version, level) {
+    const { blocks, eccPerBlock } = blockLayout(version, level);
+    return totalCodewords(version) - blocks * eccPerBlock;
+}
+/**
+ * The data codewords: the byte mode indicator 0100, the byte count, the bytes and the terminator 0000, then the pad
+ * codewords 11101100 and 00010001 by turns until the version is full. The mode and the count leave the bytes 4 bits
+ * into a codeword, so the terminator always fits, and always completes the last one.
+ */
+function dataCodewords(bytes, version, level) {
+    const bits = [];
+    const write = (value, length) => {
+        for (let i = length - 1; i >= 0; i--)
+            bits.push((value >> i) & 1);
+    };
+    write(0b0100, 4);
+    write(bytes.length, countBits(version));
+    for (const byte of bytes)
+        write(byte, 8);
+    write(0b0000, 4);
+    const codewords = [];
+    for (let i = 0; i < bits.length; i += 8) {
+        codewords.push(bits.slice(i, i + 8).reduce((byte, bit) => (byte << 1) | bit, 0));
+    }
+    const capacity = dataCodewordCount(version, level);
+    for (let pad = 0; codewords.length < capacity; pad++)
+        codewords.push(pad % 2 === 0 ? 0b11101100 : 0b00010001);
+    return codewords;
+}
+/**
+ * The data cut into the version's blocks, each followed by its check codewords, then interleaved: the first codeword of
+ * every block, then the second of every block, and so on, all the data before the check codewords. When the codewords
+ * do not share out evenly, the last blocks take one data codeword more.
+ */
+function interleave(data, version, level) {
+    const { blocks, eccPerBlock } = blockLayout(version, level);
+    const total = totalCodewords(version);
+    const shortBlocks = blocks - (total % blocks);
+    const shortLength = Math.floor(total / blocks) - eccPerBlock;
+    const generator = generatorPolynomial(eccPerBlock);
+    const dataBlocks = [];
+    const eccBlocks = [];
+    let start = 0;
+    for (let i = 0; i < blocks; i++) {
+        const length = i < shortBlocks ? shortLength : shortLength + 1;
+        const block = data.slice(start, start + length);
+        dataBlocks.push(block);
+        eccBlocks.push(reedSolomon(block, generator));
+        start += length;
+    }
+    const result = [];
+    for (const group of [dataBlocks, eccBlocks]) {
+        const longest = Math.max(...group.map((block) => block.length));
+        for (let i = 0; i < longest; i++) {
+            for (const block of group) {
+                const codeword = block[i];
+                if (codeword !== undefined)
+                    result.push(codeword); // a short block has no last data codeword
+            }
+        }
+    }
+    return result;
+}
+/** Multiplies two elements of GF(256), the field of the codewords, reduced by x^8 + x^4 + x^3 + x^2 + 1 (0x11D). */
+function gfMultiply(a, b) {
+    let product = 0;
+    let shifted = a;
+    for (let rest = b; rest > 0; rest >>= 1) {
+        if (rest & 1)
+            product ^= shifted;
+        shifted <<= 1;
+        if (shifted & 0x100)
+            shifted ^= 0x11d;
+    }
+    return product;
+}
+/** (x - 1)(x - 2)(x - 2^2)...(x - 2^(degree - 1)): the coefficients, highest power first, without the leading 1. */
+function generatorPolynomial(degree) {
+    let poly = [1];
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        // Times (x + root), since minus is plus in GF(256): each coefficient moves one power up, plus root times the next.
+        poly = [...poly, 0].map((coefficient, j) => coefficient ^ gfMultiply(poly[j - 1] ?? 0, root));
+        root = gfMultiply(root, 2);
+    }
+    return poly.slice(1);
+}
+/** A block's check codewords: what is left of its data, times x^degree, divided by the generator. */
+function reedSolomon(data, generator) {
+    let rest = generator.map(() => 0);
+    for (const codeword of data) {
+        const factor = codeword ^ (rest[0] ?? 0);
+        rest = generator.map((coefficient, i) => (rest[i + 1] ?? 0) ^ gfMultiply(coefficient, factor));
+    }
+    return rest;
+}
+/** The check bits of a BCH code: the remainder of value x 2^count divided by the generator, in GF(2). */
+function bchCheckBits(value, generator, count) {
+    let rest = value << count;
+    for (let bit = 31 - Math.clz32(rest); bit >= count; bit--) {
+        if ((rest >> bit) & 1)
+            rest ^= generator << (bit - count);
+    }
+    return rest;
+}
+/** Draws a function module: the codewords and the mask leave it alone. */
+function setFixed(grid, x, y, dark) {
+    grid.dark[y * grid.size + x] = dark;
+    grid.fixed[y * grid.size + x] = true;
+}
+/** A version's function patterns, every other module light and free for the codewords. */
+function functionPatterns(version) {
+    const size = version * 4 + 17;
+    const grid = { size, dark: new Array(size * size).fill(false), fixed: new Array(size * size).fill(false) };
+    // The timing patterns along row 6 and column 6, dark on the even modules; the finders cover their ends.
+    for (let i = 0; i < size; i++) {
+        setFixed(grid, 6, i, i % 2 === 0);
+        setFixed(grid, i, 6, i % 2 === 0);
+    }
+    drawFinder(grid, 3, 3);
+    drawFinder(grid, size - 4, 3);
+    drawFinder(grid, 3, size - 4);
+    // An alignment pattern at every pair of centres, but the three corners where the finders are.
+    const centres = alignmentCentres(version);
+    const last = centres.length - 1;
+    centres.forEach((y, row) => {
+        centres.forEach((x, column) => {
+            const onFinder = (row === 0 && column === 0) || (row === 0 && column === last) || (row === last && column === 0);
+            if (!onFinder)
+                drawAlignment(grid, x, y);
+        });
+    });
+    // Room for the format information, drawn again with each mask, the dark module, and the version information.
+    drawFormat(grid, "M", 0);
+    drawVersion(grid, version);
+    return grid;
+}
+/** A finder pattern centred on (x, y): 7 x 7, with its light separator around it, cut off at the code's edge. */
+function drawFinder(grid, x, y) {
+    for (let dy = -4; dy <= 4; dy++) {
+        for (let dx = -4; dx <= 4; dx++) {
+            const column = x + dx;
+            const row = y + dy;
+            if (column < 0 || row < 0 || column >= grid.size || row >= grid.size)
+                continue;
+            // Rings out from the centre: 0 and 1 the dark 3 x 3, 2 light, 3 the dark frame, 4 the separator.
+            const ring = Math.max(Math.abs(dx), Math.abs(dy));
+            setFixed(grid, column, row, ring !== 2 && ring !== 4);
+        }
+    }
+}
+/** An alignment pattern centred on (x, y): 5 x 5, a dark frame, a light ring and a dark centre. */
+function drawAlignment(grid, x, y) {
+    for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+            setFixed(grid, x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+        }
+    }
+}
+/**
+ * The format information: the level's two bits and the mask's three, ten BCH check bits after them, all XORed with
+ * 101010000010010 so that it is never all light. One copy around the top-left finder, the other split between the two
+ * other finders; and the dark module, always dark.
+ */
+function drawFormat(grid, level, mask) {
+    const data = (LEVEL_BITS[level] << 3) | mask;
+    const bits = ((data << 10) | bchCheckBits(data, 0b10100110111, 10)) ^ 0b101010000010010;
+    const bit = (i) => ((bits >> i) & 1) === 1;
+    const { size } = grid;
+    // Bits 0 to 7 down column 8 beside the top-left finder, stepping over the timing row; 8 to 14 leftwards along row 8.
+    for (let i = 0; i <= 5; i++)
+        setFixed(grid, 8, i, bit(i));
+    setFixed(grid, 8, 7, bit(6));
+    setFixed(grid, 8, 8, bit(7));
+    setFixed(grid, 7, 8, bit(8));
+    for (let i = 9; i < 15; i++)
+        setFixed(grid, 14 - i, 8, bit(i));
+    // The copy: bits 0 to 7 leftwards along row 8 from the right edge, 8 to 14 down column 8 to the bottom edge.
+    for (let i = 0; i < 8; i++)
+        setFixed(grid, size - 1 - i, 8, bit(i));
+    for (let i = 8; i < 15; i++)
+        setFixed(grid, 8, size - 15 + i, bit(i));
+    setFixed(grid, 8, size - 8, true);
+}
+/**
+ * From version 7, the version in 6 bits and 12 BCH check bits after them: a block 3 wide and 6 tall left of the
+ * top-right finder, and the same bits mirrored, 6 wide and 3 tall, over the bottom-left finder.
+ */
+function drawVersion(grid, version) {
+    if (version < 7)
+        return;
+    const bits = (version << 12) | bchCheckBits(version, 0b1111100100101, 12);
+    for (let i = 0; i < 18; i++) {
+        const dark = ((bits >> i) & 1) === 1;
+        const column = grid.size - 11 + (i % 3);
+        const row = Math.floor(i / 3);
+        setFixed(grid, column, row, dark);
+        setFixed(grid, row, column, dark);
+    }
+}
+/**
+ * The codewords' bits, the most significant first, in the zigzag the standard reads them in: two columns at a time
+ * from the right edge, up the first pair and down the next, the right column before the left, around every function
+ * module. What is left after the last codeword (0 to 7 remainder bits) stays light.
+ */
+function placeCodewords(grid, codewords) {
+    const { size } = grid;
+    let bit = 0;
+    let upward = true;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5; // column 6 is the vertical timing pattern: the pairs step over it
+        for (let step = 0; step < size; step++) {
+            const y = upward ? size - 1 - step : step;
+            for (const x of [right, right - 1]) {
+                const at = y * size + x;
+                if (grid.fixed[at])
+                    continue;
+                const codeword = codewords[bit >> 3];
+                grid.dark[at] = codeword !== undefined && ((codeword >> (7 - (bit & 7))) & 1) === 1;
+                bit++;
+            }
+        }
+        upward = !upward;
+    }
+}
+/** A copy of the code with mask pattern `mask` applied to every module the function patterns leave free, and its format information. */
+function withMask(grid, level, mask) {
+    const masked = { size: grid.size, dark: grid.dark.slice(), fixed: grid.fixed };
+    for (let y = 0; y < grid.size; y++) {
+        for (let x = 0; x < grid.size; x++) {
+            const at = y * grid.size + x;
+            if (!grid.fixed[at] && maskFlips(mask, x, y))
+                masked.dark[at] = !masked.dark[at];
+        }
+    }
+    drawFormat(masked, level, mask);
+    return masked;
+}
+/** Whether mask pattern `mask` flips the module at column x, row y (Table 10, where i is the row and j the column). */
+function maskFlips(mask, x, y) {
+    switch (mask) {
+        case 0:
+            return (y + x) % 2 === 0;
+        case 1:
+            return y % 2 === 0;
+        case 2:
+            return x % 3 === 0;
+        case 3:
+            return (y + x) % 3 === 0;
+        case 4:
+            return (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0;
+        case 5:
+            return ((y * x) % 2) + ((y * x) % 3) === 0;
+        case 6:
+            return (((y * x) % 2) + ((y * x) % 3)) % 2 === 0;
+        case 7:
+            return (((y + x) % 2) + ((y * x) % 3)) % 2 === 0;
+        default:
+            return false;
+    }
+}
+/** A masked code's penalty points by the four rules of ISO/IEC 18004 7.8.3: the fewer, the easier it reads. */
+function penalty(grid) {
+    const { size, dark } = grid;
+    let points = 0;
+    // Rules 1 and 3, along every row and every column.
+    for (let i = 0; i < size; i++) {
+        const row = [];
+        const column = [];
+        for (let j = 0; j < size; j++) {
+            row.push(dark[i * size + j] === true);
+            column.push(dark[j * size + i] === true);
+        }
+        points += runPoints(row) + finderPoints(row) + runPoints(column) + finderPoints(column);
+    }
+    // Rule 2: 3 points for every 2 x 2 block of one colour, overlapping blocks each counted.
+    for (let y = 0; y + 1 < size; y++) {
+        for (let x = 0; x + 1 < size; x++) {
+            const at = y * size + x;
+            const colour = dark[at];
+            if (dark[at + 1] === colour && dark[at + size] === colour && dark[at + size + 1] === colour)
+                points += 3;
+        }
+    }
+    // Rule 4: 10 points for every whole 5% that the share of dark modules is away from half.
+    const darkCount = dark.filter(Boolean).length;
+    points += 10 * Math.floor(Math.abs(darkCount * 20 - size * size * 10) / (size * size));
+    return points;
+}
+/** Rule 1: a run of five or more modules of one colour scores 3, and 1 more for every module past the fifth. */
+function runPoints(line) {
+    let points = 0;
+    let run = 0;
+    for (let i = 0; i < line.length; i++) {
+        run = i > 0 && line[i] === line[i - 1] ? run + 1 : 1;
+        if (run === 5)
+            points += 3;
+        else if (run > 5)
+            points += 1;
+    }
+    return points;
+}
+/** Rule 3: 40 points for a finder-like run with four light modules before it, and 40 with four after it. */
+function finderPoints(line) {
+    // Past either end is the quiet zone, which is light.
+    const light = (i) => line[i] !== true;
+    const fourLight = (from) => light(from) && light(from + 1) && light(from + 2) && light(from + 3);
+    let points = 0;
+    for (let start = 0; start + FINDER_LIKE.length <= line.length; start++) {
+        if (!FINDER_LIKE.every((dark, j) => line[start + j] === dark))
+            continue;
+        if (fourLight(start - 4))
+            points += 40;
+        if (fourLight(start + FINDER_LIKE.length))
+            points += 40;
+    }
+    return points;
+}

package/dist/Helpers/RecordCards.d.ts

@@ -0,0 +1,205 @@
+import type { ApiEndpoint, ApiResult } from "../Interfaces/ApiInterfaces.ts";
+import type { DatePreferences } from "../Interfaces/DateInterfaces.ts";
+import { type FormValues, type InputParams } from "../Interfaces/FormInterfaces.ts";
+import type { RecordCardParams, RecordContentCardParams, RecordContext, RecordFieldParams, RecordFieldsCardParams, RecordFlowParams, RecordItemsCardParams, RecordRead, RecordSourceParams, RecordStepParams, RecordWrites } from "../Interfaces/RecordInterfaces.ts";
+/** A fields card with its data's type: `fieldsCard<Profile>({ ... })`. */
+export declare const fieldsCard: <TData>(card: RecordFieldsCardParams<TData>) => RecordFieldsCardParams<TData>;
+/** An items card with its data's and its items' types: `itemsCard<ContactList, Contact>({ ... })`. */
+export declare const itemsCard: <TData, TItem>(card: RecordItemsCardParams<TData, TItem>) => RecordItemsCardParams<TData, TItem>;
+/** A card of the page's own, with its data's type. */
+export declare const contentCard: <TData>(card: RecordContentCardParams<TData>) => RecordContentCardParams<TData>;
+/** Which of the three a card is. */
+export declare function recordCardKind(card: RecordCardParams): "fields" | "items" | "content";
+/** A field given as its input alone, or with its own label and look: always the second. */
+export declare function recordField<TData>(entry: InputParams | RecordFieldParams<TData>): RecordFieldParams<TData>;
+/**
+ * What a popup's form opens on, of the record or the item it works on: the values its inputs name that an input can hold
+ * (text, a number, a yes or no, a list of those; rows for a rows input - Tabular, Group). A field of another shape - the
+ * code record of a contact, when the step's box is also called `code` - is left out, so the box opens empty rather than
+ * on "[object Object]". Rows are kept whole: an Edit that opened with no rows would send none and wipe them.
+ */
+export declare function recordOpenedValues(given: unknown, inputs: readonly InputParams[]): FormValues;
+/** A fields card's Edit inputs: the fields' own, without those only shown (`edit: false`) or that hold no value. */
+export declare function recordFieldInputs(card: Pick<RecordFieldsCardParams, "fields">): InputParams[];
+/** How one value reads in a card. */
+export type RecordValueView = {
+    kind: "empty";
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "lines";
+    text: string;
+} | {
+    kind: "chips";
+    items: string[];
+} | {
+    kind: "markdown";
+    text: string;
+} | {
+    kind: "rich";
+    html: string;
+};
+/** Whether a field takes the card's whole width when it does not say: long text, chips and editors do. */
+export declare function recordFieldWide(field: RecordFieldParams): boolean;
+/** What a field holds while its source loads, so the card is as tall as it will be: a line, two lines, or a chip's row. */
+export declare function recordFieldHeld(field: RecordFieldParams): "line" | "lines" | "chips";
+/** How many lines a value held as lines holds while its source loads: the field's `heldLines`, else two. */
+export declare function recordHeldLines(field: Pick<RecordFieldParams, "heldLines">): number;
+/**
+ * A value as a card draws it, from the input that edits it: a choice by its label, a date in the person's format, a
+ * number with its format, a yes or a no, a list as chips (`look: "chips"`, a multiple choice, a group of checkboxes), long
+ * text on its own lines, Markdown and rich text as such, a password never. Empty when there is nothing to say.
+ */
+export declare function recordValueView(params: InputParams, value: unknown, options?: {
+    look?: RecordFieldParams["look"];
+    preferences?: DatePreferences;
+}): RecordValueView;
+/** A card's items: the field it names, what its function answers, or the data itself when that is the list. */
+export declare function recordItems<TItem>(data: unknown, items?: string | ((data: any) => readonly TItem[])): readonly TItem[];
+/** An item's key, as text. */
+export declare function recordItemKey<TItem>(item: TItem, itemKey: string | ((item: TItem) => string | number)): string;
+/** The data with these items in place of its own, or `null` when the items come from a function (which cannot be set). */
+export declare function recordWithItems(data: unknown, items: string | ((data: any) => readonly unknown[]) | undefined, next: readonly unknown[]): unknown;
+/** The most a card's list may hold, by its `limit`: a number, a field of the data, or a function. `null` for no limit. */
+export declare function recordLimit(data: unknown, limit: RecordItemsCardParams["limit"]): number | null;
+/** "3 of 5", or "3" with no limit. */
+export declare const recordCount: (count: number, limit: number | null) => string;
+/** Why Add is held at the limit. */
+export declare function recordLimitReason(limit: number, reason: RecordItemsCardParams["limitReason"]): string;
+/** What a write does to the card's data: its new value, a read again, or nothing. */
+export type RecordWriteOutcome = {
+    kind: "write";
+    data: unknown;
+} | {
+    kind: "reload";
+} | {
+    kind: "none";
+};
+export interface RecordWriteRequest {
+    writes: RecordWrites | undefined;
+    /** What the server answered. */
+    result: unknown;
+    /** The card's data as held now - never as the popup was opened on, so a change made meanwhile stays. */
+    data: unknown;
+    /** The values sent (before `transform`). */
+    values: unknown;
+    /** What an answer that is no record does under `"answer"`: a card's Edit writes its values, the rest read again. */
+    fallback: "values" | "reload";
+    /** The card's items, for `"item"` and `"remove"`. */
+    items?: string | ((data: any) => readonly unknown[]);
+    itemKey?: string | ((item: any) => string | number);
+    /** The item acted on, for `"remove"`. */
+    item?: unknown;
+}
+/**
+ * What an answer writes into the card's data, as `writes` says (`RecordWrites`). Everything merges over the data as held
+ * now; a list (`"item"`, `"remove"`) is written back only where the card names its field or the data is the list, else
+ * the source is read again.
+ */
+export declare function recordWrite(request: RecordWriteRequest): RecordWriteOutcome;
+/** Whether an action shows, and when it is held, why. */
+export type RecordActionState = {
+    kind: "hidden";
+} | {
+    kind: "held";
+    reason: string;
+} | {
+    kind: "ready";
+};
+/** The endpoint an action calls first, when it is one: the action shows only to a person who may call it. */
+export declare function recordActionEndpoint(action: {
+    flow?: RecordFlowParams;
+    confirm?: {
+        submit: unknown;
+    };
+}): ApiEndpoint | undefined;
+/** What a heading's button says while its card's data is read. */
+export declare const RECORD_STILL_READ = "Still being read.";
+/**
+ * An action's state: hidden on a read-only card, by its own rule, or to a person who may not call its endpoint; held with
+ * its reason; else ready. `args` is `null` while the data is still read: the rules typed on the data are not asked then,
+ * and the action is held ("Still being read.") or, with `loading: "hidden"`, not drawn yet.
+ */
+export declare function recordActionState(action: {
+    hidden?: (...args: any[]) => boolean;
+    held?: (...args: any[]) => string | false | null | undefined;
+    loading?: "held" | "hidden";
+    flow?: RecordFlowParams;
+    confirm?: {
+        submit: unknown;
+    };
+}, args: readonly unknown[] | null, { readOnly, can }: {
+    readOnly: boolean;
+    can: (endpoint: ApiEndpoint) => boolean;
+}): RecordActionState;
+/**
+ * A card's calls on their way, by what each works on (an item's key, or "card"): one added as it starts, that one alone
+ * taken away as it ends, so a call that ends first never frees a row whose own call still runs.
+ */
+export declare function recordBusyKeys(keys: readonly string[] | undefined, key: string, on: boolean): readonly string[];
+/** An action's accessible name with what it acts on: "Edit: Personal details", "Verify: ram@example.com". */
+export declare const recordActionName: (label: string, of: string | null | undefined) => string;
+/** A popup's steps, each with its id (its place, "1", when it names none): the flow itself when it has no `steps`. */
+export declare function recordSteps<TData, TItem>(flow: RecordFlowParams<TData, TItem>): (RecordStepParams<TData, TItem> & {
+    id: string;
+})[];
+/** The step a popup opens on: `start` when it names a step there is, else the first. */
+export declare function recordStartStep<TData, TItem>(flow: RecordFlowParams<TData, TItem>, context: RecordContext<TData, TItem>): string;
+/** The status line a step's bar keeps: the full one for a form of several inputs, the quiet one for a step of one or two. */
+export declare const recordStatusLine: (inputs: number) => "full" | "errors";
+/** The default rule for a session that ended: a 401 that names no input (a wrong password names its box). */
+export declare const recordSessionEnded: (answer: ApiResult) => boolean;
+/** Whole seconds until a moment (an ISO text or ms), never below zero. */
+export declare function secondsUntil(moment: string | number | null | undefined, now?: number): number;
+/** One source as the page holds it: on its way (with what was known before), read, or not readable. */
+export type RecordSourceState = {
+    status: "loading";
+    data: unknown;
+} | {
+    status: "ready";
+    data: unknown;
+} | {
+    status: "failed";
+    data: unknown;
+    answer: ApiResult;
+};
+/** How a source is read: its function, or a GET of its endpoint or URL by the app's client. */
+export type RecordReader = (read: RecordRead, signal: AbortSignal) => Promise<ApiResult>;
+/**
+ * The page's sources: each read once (and again on Try again or a step's `reload`), written by the answers. A read that
+ * fails before anything was read leaves the source failed; one that fails while its data shows keeps the data and only
+ * answers the failure. A newer read wins over an older one still on its way. `end` marks the session ended: the page
+ * shows its words in place of the cards and nothing more is read.
+ */
+export declare class RecordSources {
+    private states;
+    private readonly controllers;
+    private readonly listeners;
+    private endedAnswer;
+    private readonly sources;
+    private readonly reader;
+    constructor(sources: Readonly<Record<string, RecordRead | RecordSourceParams>>, reader: RecordReader);
+    /** The names, in the page's order: the first is every card's default. */
+    get names(): string[];
+    subscribe: (listener: () => void) => () => void;
+    /** Every source's state; a new object after each change, for `useSyncExternalStore`. */
+    snapshot: () => Readonly<Record<string, RecordSourceState>>;
+    get(name: string): RecordSourceState;
+    /** The answer that found the session ended, once one has. */
+    get ended(): ApiResult | null;
+    private set;
+    /** Reads every source not read yet (none read, or stopped on its way). */
+    start(): void;
+    /** Stops every read on its way; `start` reads them again. */
+    stop(): void;
+    /**
+     * Reads a source (again): resolves with the answer. A failed source goes back to loading while it runs; one that shows
+     * its data keeps it. An answer that a newer read or `stop` overtook changes nothing and resolves aborted.
+     */
+    read(name: string): Promise<ApiResult>;
+    /** Writes a source's data: every card on it follows. */
+    write(name: string, data: unknown): void;
+    /** The session ended: nothing more is read, and the page shows its words. */
+    end(answer: ApiResult): void;
+}