@docx4j/core-ts 0.1.0 → 0.1.2

package/dist/model/listnumbering/Emulator.mjs

@@ -0,0 +1,332 @@
+import { log } from '../properties/log.mjs';
+import { NumberingState } from './state.mjs';
+/**
+ * Where a paragraph's numbering comes from once its own `w:numPr` and its style chain have been
+ * read. docx4j `Emulator.NumRef` (17.1.1, CR-014 phase 3).
+ */
+export class NumRef {
+    constructor(numId, ilvl, direct, notNumbered, reason) {
+        this.numId = numId;
+        this.ilvl = ilvl;
+        this.direct = direct;
+        this.notNumbered = notNumbered;
+        this.reason = reason;
+    }
+    /** A paragraph Word numbers, at this list and level. */
+    static numbered(numId, ilvl, direct) {
+        return new NumRef(numId, ilvl, direct, false, undefined);
+    }
+    /** A paragraph Word does not number, and why. */
+    static not(reason) {
+        return new NumRef(undefined, undefined, false, true, reason);
+    }
+    toString() {
+        return this.notNumbered
+            ? `not numbered: ${this.reason}`
+            : `numId ${this.numId} ilvl ${this.ilvl} (${this.direct ? 'direct' : 'from style'})`;
+    }
+}
+function numberingPartOf(pkg) {
+    try {
+        return pkg === null || pkg === void 0 ? void 0 : pkg.getMainDocumentPart().numberingDefinitionsPart;
+    }
+    catch {
+        return undefined; // no main document part
+    }
+}
+/**
+ * The numbering of one package's numbering part: the definitions, the `PropertyResolver` the
+ * resolution goes through, and the part's default {@link NumberingState}.
+ *
+ * docx4j's `Emulator` is a marker object with static methods over maps the part holds; here the
+ * instance carries what those statics look up, and the statics delegate to it.
+ */
+export class Emulator {
+    constructor(
+    /** The definitions this emulator counts in. */
+    definitions, 
+    /** The resolver a style-contributed `w:numPr` is read through; undefined disables that path. */
+    resolver, state = new NumberingState()) {
+        this.definitions = definitions;
+        this.resolver = resolver;
+        this.state = state;
+    }
+    /** The counters the state-less calls use. docx4j `NumberingDefinitionsPart.getNumberingState()`. */
+    get numberingState() {
+        return this.state;
+    }
+    /** Every list starts again: what `getEmulator(true)` does to the part's default state. */
+    newState() {
+        this.state = new NumberingState();
+        return this.state;
+    }
+    // ---------------------------------------------------------------- resolution
+    /**
+     * Whether this level belongs to a **different** paragraph style than the one which brought the
+     * numbering to this paragraph, in which case Word paints no label and does not count the
+     * paragraph. docx4j `Emulator.styleLinkedElsewhere` (17.1.0, measured on `numbering-label-ilvl0`).
+     *
+     * ECMA-376 17.9.24's `w:pStyle` inside a `w:lvl` names the paragraph style the level is linked
+     * to.  The style itself, or any style it is based on, counts as the level's own.  Direct
+     * formatting is never suppressed: a paragraph whose *own* `w:numPr` names such a level is
+     * numbered.
+     */
+    styleLinkedElsewhere(numId, ilvl, pStyleVal) {
+        var _a, _b;
+        const linked = this.definitions.getLinkedStyleId(numId, ilvl);
+        if (linked === undefined || linked === '')
+            return false;
+        if (pStyleVal === undefined)
+            return true;
+        const seen = new Set();
+        let id = pStyleVal;
+        while (id !== undefined && !seen.has(id)) {
+            seen.add(id);
+            if (linked === id)
+                return false;
+            const style = (_a = this.resolver) === null || _a === void 0 ? void 0 : _a.getStyle(id);
+            id = (_b = style === null || style === void 0 ? void 0 : style.basedOn) === null || _b === void 0 ? void 0 : _b.val;
+        }
+        return true;
+    }
+    /**
+     * The one resolution of numId and ilvl for a paragraph. docx4j `Emulator.resolve`
+     * (CR-014 phase 3, which collapsed `getNumber`'s and `getInd`'s two copies onto it).
+     *
+     * From the paragraph's own `w:numPr` where it has one; otherwise from the *effective* `w:pPr`
+     * of its paragraph style - the `w:default="1"` paragraph style when it names none, since that
+     * style may itself be numbered (measured, CR-014 P6) - then the `w:numId` 0 rule and the
+     * §2.8 rule for a style-contributed level linked to another style.
+     *
+     * @param numId       the paragraph's numId, or undefined/"" to read the style
+     * @param ilvl        the paragraph's ilvl, or undefined/"" for the style's, else "0"
+     * @param directNumPr whether a numId given here is the paragraph's own
+     */
+    resolve(pStyleVal, numId, ilvl, directNumPr) {
+        var _a, _b, _c, _d;
+        let styleId = pStyleVal === undefined || pStyleVal === '' ? undefined : pStyleVal;
+        let direct = directNumPr;
+        let list = numId === undefined || numId === '' ? undefined : numId;
+        let level = ilvl === undefined || ilvl === '' ? undefined : ilvl;
+        if (list === undefined) {
+            // no explicit numId: is it provided by the style (ie does this style, or the default
+            // paragraph style, have a list associated with it)?
+            direct = false;
+            if (styleId === undefined) {
+                styleId = (_a = this.resolver) === null || _a === void 0 ? void 0 : _a.getDefaultParagraphStyleId();
+                if (styleId === undefined) {
+                    return NumRef.not('no numId, no paragraph style and no default paragraph style');
+                }
+            }
+            let pPr;
+            try {
+                pPr = (_b = this.resolver) === null || _b === void 0 ? void 0 : _b.getEffectivePPr(styleId);
+            }
+            catch (e) {
+                log.warn(String(e));
+                return NumRef.not(`cyclic styles at ${styleId}`);
+            }
+            if (pPr === undefined)
+                return NumRef.not(`style '${styleId}' has no pPr`);
+            const numPr = pPr.numPr;
+            if (numPr === undefined) {
+                // no numbering set on the style either; that's ok
+                return NumRef.not(`no numId, and style '${styleId}' is not numbered`);
+            }
+            if (((_c = numPr.numId) === null || _c === void 0 ? void 0 : _c.val) === undefined) {
+                return NumRef.not(`style '${styleId}' has a w:numPr without a w:numId val`);
+            }
+            list = String(numPr.numId.val);
+            if (level === undefined) {
+                // w:ilvl (and its w:val) is optional; its absence means level 0
+                level = ((_d = numPr.ilvl) === null || _d === void 0 ? void 0 : _d.val) === undefined ? '0' : String(numPr.ilvl.val);
+            }
+        }
+        if (list === '0') {
+            // ECMA-376 17.9.18: a w:numId of 0 never references a definition; it designates the
+            // removal of numbering at this level (a paragraph or style switching an inherited list
+            // off).  docx4j adopted this reading, and these words, on 2026-09-19 (01d661547).
+            return NumRef.not(`${direct ? "the paragraph's" : `style '${styleId}'s`} w:numId 0 turns numbering off`);
+        }
+        const definition = this.definitions.list(list);
+        if (definition === undefined) {
+            // A w:numId naming no w:num - Word's own re-save leaves one behind in an untouched
+            // mc:Fallback after renumbering (docx4j CR-021 §8.5) - is not numbered, and says so
+            // here rather than as an empty result from getNumber (docx4j d34852bdd).
+            return NumRef.not(`no w:num for numId ${list}${sourceSuffix(direct, styleId)}`);
+        }
+        if (level === undefined) {
+            log.warn('No level id?! Default to 0.');
+            level = '0';
+        }
+        if (!definition.levelExists(level)) {
+            // The w:num exists but its definition has no w:lvl for this ilvl: not numbered, with
+            // the reason here rather than an empty result from getNumber (docx4j 7fba7a150).
+            return NumRef.not(`no w:lvl ${level} in w:num ${list}${sourceSuffix(direct, styleId)}`);
+        }
+        if (!direct && this.styleLinkedElsewhere(list, level, styleId)) {
+            return NumRef.not(`level ${level} of numId ${list} is linked to a paragraph style other than '${styleId}'`);
+        }
+        return NumRef.numbered(list, level, direct);
+    }
+    /**
+     * The numbering reference a paragraph resolves to, without taking a number and without
+     * touching any state. docx4j `Emulator.numRefFor` (17.1.1); never undefined.
+     */
+    numRefFor(pPr) {
+        if (pPr === undefined)
+            return NumRef.not('no pPr');
+        const [pStyleVal, numId, ilvl] = readNumPr(pPr);
+        return this.resolve(pStyleVal, numId, ilvl, numId !== undefined && numId !== '');
+    }
+    // ---------------------------------------------------------------- counting
+    /**
+     * The next number for a paragraph, from its `w:pPr` (its own `w:numPr`, else its style's),
+     * counted in `state` or in this emulator's default state.
+     *
+     * @returns undefined where the paragraph is not numbered
+     */
+    getNumber(pPr, state) {
+        if (pPr === undefined)
+            return undefined;
+        const [pStyleVal, numId, ilvl] = readNumPr(pPr);
+        return this.getNumberOf(pStyleVal, numId, ilvl, numId !== undefined && numId !== '', state);
+    }
+    /**
+     * The next number given the paragraph's style and, where it has one, its own numId and ilvl.
+     * docx4j's `getNumber(pkg, pStyleVal, numId, levelId, directNumPr, state)`.
+     */
+    getNumberOf(pStyleVal, numId, ilvl, directNumPr = numId !== undefined && numId !== '', state) {
+        const counters = state !== null && state !== void 0 ? state : this.state;
+        const ref = this.resolve(pStyleVal, numId, ilvl, directNumPr);
+        // docx4j logs the reason at DEBUG here; this package has no debug level, and a paragraph
+        // that is simply not in a list is the common case, so nothing is logged
+        if (ref.notNumbered)
+            return undefined;
+        return this.number(ref, counters);
+    }
+    /** Counts a resolved reference. The half of `getNumber` after `resolve`. */
+    number(ref, state) {
+        var _a;
+        const list = this.definitions.list(ref.numId);
+        const levelId = (_a = ref.ilvl) !== null && _a !== void 0 ? _a : '0';
+        if (list === undefined || !list.levelExists(levelId)) {
+            // Unreachable through `resolve`, which answers both cases with a `notNumbered` NumRef
+            // since docx4j d34852bdd / 7fba7a150; kept for a caller that builds a NumRef itself.
+            const reason = list === undefined
+                ? `Couldn't find list ${ref.numId}`
+                : `Couldn't find level ${levelId} in list ${ref.numId}`;
+            log.warn(reason);
+            return emptyResult(ref, reason);
+        }
+        list.incrementCounter(levelId, state);
+        const level = list.level(levelId);
+        const numString = list.currentNumberString(levelId, state);
+        const font = level.font;
+        return {
+            numString,
+            numFont: font === undefined || font === '' ? undefined : font,
+            isBullet: level.isBullet,
+            bullet: level.isBullet ? level.lvlText : undefined,
+            ind: level.ind,
+            indResolved: this.definitions.indOf(list.numId, levelId),
+            rPr: level.rPr,
+            labelRPr: level.labelRPr,
+            lvl: level.abstractLvl,
+            numId: list.numId,
+            ilvl: level.ilvl,
+            level,
+            count: level.counter(state).value,
+            notNumbered: false,
+            reason: undefined,
+        };
+    }
+    /** What {@link getNumber} would return, leaving the state as it was. docx4j `peek`. */
+    peek(pPr, state) {
+        return this.getNumber(pPr, (state !== null && state !== void 0 ? state : this.state).copy());
+    }
+    /**
+     * The indent a paragraph's numbering level contributes, resolved the way {@link getNumber}
+     * resolves the level itself and read as `NumberingDefinitionsPart.getInd` reads it: the
+     * level's own `w:ind` first, then the linked style's, following `w:basedOn`.  Undefined where
+     * the paragraph is not numbered or the level states none. docx4j `Emulator.getInd`.
+     */
+    getInd(pStyleVal, numId, ilvl) {
+        const ref = this.resolve(pStyleVal, numId, ilvl, numId !== undefined && numId !== '');
+        if (ref.notNumbered)
+            return undefined;
+        return this.definitions.indOf(ref.numId, ref.ilvl);
+    }
+    // ---------------------------------------------------------------- docx4j's static entry points
+    /** The package's emulator, or undefined where it has no numbering part. */
+    static of(pkg) {
+        var _a;
+        return (_a = numberingPartOf(pkg)) === null || _a === void 0 ? void 0 : _a.getEmulator();
+    }
+    static getNumber(pkg, second, ...rest) {
+        const emulator = Emulator.of(pkg);
+        if (emulator === undefined)
+            return undefined;
+        if (typeof second === 'string' || rest.length > 1) {
+            const [numId, ilvl, directNumPr, state] = rest;
+            return emulator.getNumberOf(second, numId, ilvl, directNumPr !== null && directNumPr !== void 0 ? directNumPr : (numId !== undefined && numId !== ''), state);
+        }
+        return emulator.getNumber(second, rest[0]);
+    }
+    /** docx4j `Emulator.peek(wmlPackage, pPr, state)`: the number, without taking it. */
+    static peek(pkg, pPr, state) {
+        const emulator = Emulator.of(pkg);
+        return emulator === null || emulator === void 0 ? void 0 : emulator.peek(pPr, state);
+    }
+    /**
+     * docx4j `Emulator.numRefFor(wmlPackage, pPr)`: where this paragraph's numbering resolves to,
+     * before any counting.  Never undefined; a package with no numbering part, a null `w:pPr` or
+     * a package whose `PropertyResolver` has not been built each answer {@link NumRef.notNumbered}
+     * with the reason.
+     */
+    static numRefFor(pkg, pPr) {
+        if (pPr === undefined)
+            return NumRef.not('no pPr');
+        const part = numberingPartOf(pkg);
+        if (part === undefined)
+            return NumRef.not('no numbering part');
+        const resolver = pkg === null || pkg === void 0 ? void 0 : pkg.propertyResolverOrUndefined;
+        if (resolver === undefined) {
+            return NumRef.not('no property resolver: await getPropertyResolver() first');
+        }
+        return part.getEmulator().numRefFor(pPr);
+    }
+    /** docx4j `Emulator.getInd(wmlPackage, pStyleVal, numId, levelId)`. */
+    static getInd(pkg, pStyleVal, numId, ilvl) {
+        var _a;
+        return (_a = Emulator.of(pkg)) === null || _a === void 0 ? void 0 : _a.getInd(pStyleVal, numId, ilvl);
+    }
+    toString() {
+        return `Emulator(${this.definitions.instanceListDefinitions.size} lists, `
+            + `${this.definitions.abstractListDefinitions.size} definitions)`;
+    }
+}
+/**
+ * Where the `w:numPr` a reason is about came from, as docx4j words it: the paragraph's own
+ * direct formatting, or the style that contributed it.
+ */
+function sourceSuffix(direct, styleId) {
+    return direct ? " (the paragraph's own)" : ` (from style '${styleId}')`;
+}
+/** The paragraph style and the two `w:numPr` values a `w:pPr` states, each as a string. */
+function readNumPr(pPr) {
+    var _a, _b, _c;
+    const pStyleVal = (_a = pPr.pStyle) === null || _a === void 0 ? void 0 : _a.val;
+    const numPr = pPr.numPr;
+    const numId = ((_b = numPr === null || numPr === void 0 ? void 0 : numPr.numId) === null || _b === void 0 ? void 0 : _b.val) === undefined ? undefined : String(numPr.numId.val);
+    const ilvl = ((_c = numPr === null || numPr === void 0 ? void 0 : numPr.ilvl) === null || _c === void 0 ? void 0 : _c.val) === undefined ? undefined : String(numPr.ilvl.val);
+    return [pStyleVal, numId, ilvl];
+}
+function emptyResult(ref, reason) {
+    return {
+        numString: undefined, numFont: undefined, isBullet: false, bullet: undefined,
+        ind: undefined, indResolved: undefined, rPr: undefined, labelRPr: undefined, lvl: undefined,
+        numId: ref.numId, ilvl: ref.ilvl, level: undefined, count: undefined,
+        notNumbered: true, reason,
+    };
+}

package/dist/model/listnumbering/definitions.d.mts

@@ -0,0 +1,251 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import type { NumberingIndents } from '../properties/styleUtil.mjs';
+import type { Counter, NumberingState } from './state.mjs';
+/** How many levels a list definition may have (ECMA-376: `w:ilvl` 0 to 8). */
+export declare const LEVELS = 9;
+/** What the definitions need of the styles: a style by id (the resolver's `getStyle`). */
+export type StyleLookup = (styleId: string) => wml.Style | undefined;
+/**
+ * One `w:lvl`: the abstract definition's level, and - for a level of a `w:num` - the instance's
+ * `w:lvlOverride/w:lvl` applied over it. docx4j `ListLevel`; the count lives in a
+ * {@link NumberingState}, keyed by {@link abstractNumId} and {@link ilvl}.
+ *
+ * Five members are **merged** attribute by attribute, as docx4j's `setOverrides` merges them -
+ * the override replaces each only where it states one: `w:start`, `w:lvlRestart`, `w:lvlText`,
+ * `w:numFmt` (and so `isBullet`), and the `w:hAnsi` of the level's `w:rPr/w:rFonts`.  Everything
+ * else is read off **one** `w:lvl`, the override where the instance has one and the abstract
+ * level otherwise ({@link controllingLvl}): `w:isLgl` (docx4j's rule, measured through
+ * `IsLglTest`), `w:pStyle`, `w:suff`, `w:lvlJc` and `w:lvlPicBulletId`.  `w:ind` and the label's
+ * `w:rPr` have rules of their own; see {@link ind} and {@link labelRPr}.
+ */
+export declare class LevelDefinition {
+    /** `w:ilvl`, as a string ("0" to "8"): the counter's key, and docx4j's map key. */
+    readonly ilvl: string;
+    /** The `w:abstractNum/w:lvl` this level was read from. */
+    abstractLvl: wml.Lvl | undefined;
+    /** The instance's `w:lvlOverride/w:lvl` for this level, or undefined. */
+    overrideLvl: wml.Lvl | undefined;
+    /** The **referencing** `w:abstractNum` (the counter's key; never the `w:numStyleLink` target's). */
+    abstractNumId: string;
+    /** The `w:num` an instance level belongs to; undefined for an abstract one. */
+    ownerNumId: string | undefined;
+    /** `w:start` **less one**, since every fetch increments first. */
+    startValue: number;
+    /** This instance level carries a `w:startOverride`, spent on the `w:num`'s first use. */
+    hasStartOverride: boolean;
+    /** `w:lvlRestart` (ECMA-376 17.9.11), or undefined where the level states none. */
+    lvlRestart: number | undefined;
+    /** `w:lvlText`: the label pattern ("%1.%2."), or a bullet level's character. */
+    lvlText: string | undefined;
+    /** `w:numFmt`, or undefined where the level states none. */
+    numFmt: wml.NumberFormat | undefined;
+    /** Whether `w:numFmt` is `bullet`. */
+    isBullet: boolean;
+    /**
+     * The `w:hAnsi` of the level's `w:rPr/w:rFonts`, or undefined.
+     *
+     * @deprecated docx4j deprecated `ListLevel.getFont()` in 17.1.1: use {@link labelRPr} and its
+     *   `w:rFonts`.  Kept because `NumberingResult.numFont` is what the goldens record.
+     */
+    font: string | undefined;
+    constructor(ilvl: string, lvl?: wml.Lvl);
+    /** Take from a `w:lvl` whatever it states; leave the rest alone. docx4j's constructor body. */
+    private read;
+    /** A copy for an instance definition. docx4j's copy constructor: no override, no owner. */
+    copy(): LevelDefinition;
+    /** Applies the instance's `w:lvlOverride/w:lvl`. docx4j `setOverrides`. */
+    applyOverride(lvl: wml.Lvl): void;
+    /** A `w:startOverride`: given effect on the first use of this `w:num` in a story. */
+    setStartValue(value: number): void;
+    /** `w:ilvl` as a number. */
+    get level(): number;
+    /**
+     * The one `w:lvl` the members docx4j does not merge are read from: the instance's override
+     * where there is one, else the abstract level's.
+     */
+    get controllingLvl(): wml.Lvl | undefined;
+    /** `w:start` as the document states it (one more than {@link startValue}). */
+    get start(): number | undefined;
+    /**
+     * `w:isLgl`: the levels this number *inherits* print in decimal whatever their own `w:numFmt`
+     * (Word's "legal style numbering": "Section 1.01" and not "Section I.01").
+     */
+    get isLgl(): boolean;
+    /** The `w:pStyle` this level is linked to (ECMA-376 17.9.24), or undefined. */
+    get pStyle(): string | undefined;
+    /** `w:suff`: what separates the label from the text (tab, space, nothing). */
+    get suff(): string | undefined;
+    /** `w:lvlJc`: how the label is justified in its column. */
+    get lvlJc(): wml.JcEnumeration | undefined;
+    /** `w:lvlPicBulletId`: the `w:numPicBullet` a picture bullet level names. */
+    get lvlPicBulletId(): number | undefined;
+    /** The level's `w:pPr`: the override's where it has one, else the abstract level's. */
+    get pPr(): wml.PPr | undefined;
+    /**
+     * The level's **own** `w:ind`: the instance's override level's where *it* states one, else the
+     * abstract level's (docx4j `Emulator.getNumber`'s `triple.ind`, since 17.1.0).  The linked
+     * `w:pStyle`'s is not consulted here; {@link NumberingDefinitions.getInd} does that.
+     */
+    get ind(): wml.PPrBase.Ind | undefined;
+    /** The **abstract** level's `w:rPr`, never the override's. docx4j `NumberingResult.getRPr()`. */
+    get rPr(): wml.RPr | undefined;
+    /**
+     * The `w:rPr` the label is drawn with: the `w:lvlOverride/w:lvl`'s where the instance
+     * overrides this level with one carrying an rPr, else the abstract level's - one or the other,
+     * as Word applies them (CR-014 probe P3, measured: an abstract `w:i` under an override
+     * `w:b` + `w:sz 36` gives a bold 18pt label with no italic anywhere).  It formats the number
+     * alone, never the paragraph's text (ECMA-376 17.9.24).
+     */
+    get labelRPr(): wml.RPr | undefined;
+    /** This level's counter in the given state. */
+    counter(state: NumberingState): Counter;
+    /**
+     * One more item at this level. docx4j `incrementCounter(state)`.
+     *
+     * The shared counter takes this level's start value the first time it is met in the state, and
+     * again the first time this instance level's `w:num` is met there when that `w:num` overrides
+     * the start - deferred until then, since otherwise earlier numbering over the same abstract
+     * list would use it.
+     */
+    incrementCounter(state: NumberingState): void;
+    /**
+     * A shallower level was used: the level shows its start value from now until it is next used,
+     * and that first use does not increment it (CR-014 probe P8; before, the counter went to
+     * start-1 and a deeper label printed "2.0.1" where Word prints "2.1.1").
+     */
+    resetCounter(state: NumberingState): void;
+    /**
+     * Whether using `shallowerIlvl` (0-based) restarts this level. ECMA-376 17.9.11: without
+     * `w:lvlRestart` any shallower level restarts it; `w:val="0"` means none does; `w:val="n"`
+     * means levels 1..n (1-based, so ilvl 0..n-1) do and deeper ones do not.  Measured, P8.
+     */
+    restartsAfter(shallowerIlvl: number): boolean;
+    /** The count at this level, in this level's `w:numFmt`. */
+    currentValueFormatted(state: NumberingState, where?: string): string;
+    /** The count at this level as a decimal, whatever its `w:numFmt` (what `w:isLgl` shows). */
+    currentValueUnformatted(state: NumberingState): string;
+    toString(): string;
+}
+/**
+ * One `w:abstractNum`: its levels, and - where it carries `w:numStyleLink` - the numbering style
+ * whose definition it takes them from. docx4j `AbstractListNumberingDefinition`.
+ */
+export declare class AbstractListDefinition {
+    readonly abstractNum: wml.Numbering.AbstractNum;
+    /** `w:abstractNumId`. */
+    readonly id: string;
+    /** The levels, keyed by `w:ilvl` ("0" to "8"). */
+    readonly levels: Map<string, LevelDefinition>;
+    /** `w:numStyleLink`: the numbering style this definition takes its levels from. */
+    readonly linkedStyleId: string | undefined;
+    /** `w:styleLink`: the inverse pointer, read and not acted on, as docx4j. */
+    readonly styleLink: string | undefined;
+    constructor(abstractNum: wml.Numbering.AbstractNum);
+    private readLevels;
+    /** Adds (or replaces) the level read from this `w:lvl`. docx4j `readLevel`. */
+    readLevel(lvl: wml.Lvl): void;
+    /**
+     * The second pass for a definition carrying `w:numStyleLink`: read its levels from the
+     * abstract definition the numbering style's own `w:num` names.  They count under **this**
+     * definition's id, not the linked one's. docx4j `updateDefinitionFromLinkedStyle`.
+     */
+    updateFromLinkedStyle(linked: wml.Numbering.AbstractNum): void;
+    /** Whether this definition carries `w:numStyleLink`. */
+    get hasLinkedStyle(): boolean;
+    /** How many levels are defined; 0 for an unresolved `w:numStyleLink` definition. */
+    get levelCount(): number;
+}
+/**
+ * One `w:num`: the abstract definition it names, with its `w:lvlOverride`s applied to copies of
+ * that definition's levels, and the counting. docx4j `ListNumberingDefinition`.
+ */
+export declare class ListDefinition {
+    readonly num: wml.Numbering.Num;
+    /** `w:numId`. */
+    readonly numId: string;
+    /** The abstract definition this names, or undefined. */
+    readonly abstractDefinition: AbstractListDefinition | undefined;
+    /** The levels, with this instance's overrides applied. */
+    readonly levels: Map<string, LevelDefinition>;
+    constructor(num: wml.Numbering.Num, abstracts: ReadonlyMap<string, AbstractListDefinition>, resolveLinkedStyle: boolean);
+    /** The level with this `w:ilvl`, or undefined. */
+    level(ilvl: string | number): LevelDefinition | undefined;
+    /** Whether the level exists: Word writes `w:num`s whose abstract definition or level is missing. */
+    levelExists(ilvl: string | number): boolean;
+    /** Whether the level's `w:numFmt` is `bullet`. */
+    isBullet(ilvl: string | number): boolean;
+    /** The `w:hAnsi` font the level's `w:rPr` names, or undefined. */
+    font(ilvl: string | number): string | undefined;
+    /**
+     * One more item at a level, and the deeper levels that restart after it reset.
+     * docx4j `incrementCounter(level, state)`.
+     */
+    incrementCounter(ilvl: string | number, state: NumberingState): void;
+    /**
+     * The label of a level: its `w:lvlText` with the counters filled in ("1.2.", "(c)").
+     * docx4j `getCurrentNumberString(level, state)`.
+     *
+     * `w:isLgl` at **any** level shows the levels this number *inherits* in decimal whatever their
+     * own `w:numFmt`, the level carrying it keeping its own: Word's Article / Section numbering
+     * prints "Section 1.01" where the plain reading would print "Section I.01".
+     */
+    currentNumberString(ilvl: string | number, state: NumberingState): string;
+}
+/**
+ * The definitions of one `w:numbering`: every `w:abstractNum` and every `w:num`, with
+ * `w:numStyleLink` resolved. docx4j `NumberingDefinitionsPart.initialiseMaps` and the two maps
+ * it fills, plus `getInd` and `getLinkedStyleId`.
+ *
+ * Immutable once built; the numbering part rebuilds it when its tree changes.
+ */
+export declare class NumberingDefinitions implements NumberingIndents {
+    readonly numbering: wml.Numbering | undefined;
+    private readonly getStyle;
+    /** `w:abstractNumId` -> the definition. docx4j `getAbstractListDefinitions()`. */
+    readonly abstractListDefinitions: Map<string, AbstractListDefinition>;
+    /** `w:numId` -> the definition. docx4j `getInstanceListDefinitions()`. */
+    readonly instanceListDefinitions: Map<string, ListDefinition>;
+    /**
+     * @param numbering the `w:numbering` tree, or undefined for a package with no numbering part
+     * @param getStyle  a style by id, for `w:numStyleLink` and a level's linked `w:pStyle`
+     */
+    constructor(numbering: wml.Numbering | undefined, getStyle?: StyleLookup);
+    private readInstances;
+    /**
+     * docx4j `resolveLinkedAbstractNum`: the numbering style `w:numStyleLink` names, the `w:num`
+     * its `w:numPr` points at, and *that* `w:num`'s abstract definition, whose levels this one
+     * takes while counting under its own id - "treated as a separate list by Word (ie its numbers
+     * are incremented independently), and this code honours that".
+     */
+    private resolveLinkedAbstractNum;
+    /** The definition of a `w:numId`, or undefined. */
+    list(numId: string | number | undefined): ListDefinition | undefined;
+    /** The level of a `w:numId` / `w:ilvl`, or undefined. */
+    level(numId: string | number | undefined, ilvl: string | number | undefined): LevelDefinition | undefined;
+    /**
+     * The paragraph style this level is linked to - the `w:pStyle` of ECMA-376 17.9.24, on the
+     * instance's `w:lvlOverride/w:lvl` where it has one and on the abstract level otherwise - or
+     * undefined. docx4j `NumberingDefinitionsPart.getLinkedStyleId`.
+     */
+    getLinkedStyleId(numId: string | undefined, ilvl: string | undefined): string | undefined;
+    /** docx4j `NumberingDefinitionsPart.getInd(NumPr)`: `w:ilvl` is optional and means level 0. */
+    getInd(numPr: wml.PPrBase.NumPr): wml.PPrBase.Ind | undefined;
+    /**
+     * The indent this level contributes. docx4j `NumberingDefinitionsPart.getInd(String, String)`:
+     * the instance's override level first, then the abstract level, each read by
+     * {@link indFromLvl}.
+     */
+    indOf(numId: string, ilvl: string | undefined): wml.PPrBase.Ind | undefined;
+    /**
+     * **The level's own `w:pPr/w:ind` comes first** (ECMA-376 17.9.24: a `w:lvl/w:pPr` states the
+     * paragraph properties applied to a paragraph at this level).  A `w:lvl/w:pStyle` only *links*
+     * the level to a paragraph style; it does not make that style's indent the level's.  Where the
+     * level states no indent of its own the linked style's is still used, following `w:basedOn` as
+     * every other property a style contributes does (docx4j 17.1.0 and 17.1.1; CR-014 claim 7,
+     * measured, and probe P5).
+     *
+     * A style reference in the level's `w:pPr`, but not also as a sibling of `w:pPr`, contributes
+     * nothing here - and numbers nothing (CR-014 P4; `Emulator.resolve` decides "not numbered").
+     */
+    private indFromLvl;
+}