@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

package/types/src/named/NamedCollection.d.ts

@@ -0,0 +1,302 @@
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ICellRanges } from '../cellRange';
+import { INamed, INamedCollection } from '../named';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+export declare const REGEX_INVALID_NAME_FIRST_CHARS: RegExp;
+export declare const REGEX_INVALID_NAME_TRAILING_CHARS: RegExp;
+/**
+ * Implementation for `INamedCollection`.
+ */
+export declare class NamedCollection implements INamedCollection {
+    protected _emitter: ListenerEmitter<this, INamedCollection.IListeners>;
+    private _options;
+    private _transactions;
+    private _closed;
+    private _lastLookup;
+    private _lastLookupAddress;
+    private _lastLookupType;
+    private _lastIncludeHidden;
+    private _lastAllowExtrudes;
+    private _lastLookupName;
+    /** `undefined` means the scope key was absent — `null` is a real query (global items only). */
+    private _lastLookupScope;
+    private _lastLookupHasScope;
+    /** Resolves the registries to aggregate. Lazy — see {@link NamedCollection.ConstructorOptions.getSources}. */
+    private _getSources;
+    /** Last resolved set, and the subscriptions held against it. */
+    private _sources;
+    private _sourcesRemoveListeners;
+    constructor(options: NamedCollection.ConstructorOptions);
+    /**
+     * The registries to aggregate, resolving the callback and reconciling subscriptions.
+     *
+     * @remarks
+     * Resolved on every query rather than once at construction: the calculation engine takes this
+     * collection, so it does not exist yet when this is built. Laziness is what breaks that cycle —
+     * see {@link NamedCollection.ConstructorOptions.getSources}.
+     *
+     * **Push events.** A source mutating behind us has to drop the lookup memo and reach our
+     * listeners, or a cached result outlives the data it was built from. Subscriptions are rebuilt
+     * only when the resolved set actually changes, so re-resolving stays cheap and listeners are not
+     * churned on every read.
+     */
+    private _resolveSources;
+    /**
+     * The source that owns defined names — the one able to create them.
+     *
+     * @remarks
+     * `null` before the owner has wired one up — the sources resolve lazily, so this is reachable
+     * mid-construction. {@link addFormula} throws in that window rather than inventing a home for
+     * the name.
+     */
+    private _getOwningSource;
+    /** {@inheritDoc ICollection.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<INamed>;
+    /** {@inheritDoc INamedCollection.getItems} */
+    getItems(options?: INamedCollection.GetItemsOptions): INamed[];
+    /** {@inheritDoc INamedCollection.getByRanges} */
+    getByRanges(ranges: ICellRanges.Address, options?: INamedCollection.GetByRangesOptions): string[];
+    /** {@link getByRanges}, against an explicit anchor — see {@link _scopedTo}. */
+    _getByRanges(ranges: ICellRanges.Address, options: INamedCollection.GetByRangesOptions | undefined, anchor: NamedCollection.Anchor | null): string[];
+    /**
+     * The address as sorted, sheet-qualified coords — the form an exact match can be made against.
+     *
+     * @remarks
+     * A named item's coords are always sheet-qualified, because a name is workbook-addressable and
+     * may span sheets. A *sheet's* coords — a selection, most of all — are local and carry no
+     * `scope` at all. Since `scope` is part of coords identity (`CoordUtils.isEqualRanges`, where the
+     * same row/col on two sheets are deliberately not equal), the two can never compare equal until
+     * the local side is qualified. An unqualified coord is read as being on the current scope, which
+     * is what lets `sheet.getSelection().getRanges()` be passed straight in.
+     *
+     * Sorted so that a multi-range name matches however the ranges were given — a user shift-picking
+     * the second range first still selected the same region.
+     */
+    private _qualifyCoords;
+    /**
+     * Every candidate item, across the pushed store and the injected sources.
+     *
+     * @param searchCoords The address filter, or `null` for everything.
+     */
+    private _collectCandidates;
+    /**
+     * Whether a source item overlaps the address filter.
+     *
+     * @remarks
+     * An item that designates no ranges — a value name like `=1`, or one whose formula has not been
+     * wired yet — is never a positional match, so an address query simply does not see it. It is
+     * still returned by an unfiltered query.
+     */
+    private _matchesCoords;
+    /** {@inheritDoc INamedCollection.getByName} */
+    getByName(name: string, global?: boolean): INamed | null;
+    /** {@link getByName}, against an explicit `scope` — see {@link _scopedTo}. */
+    _getByName(name: string, global?: boolean, scope?: string | null): INamed | null;
+    /** The scope an unqualified query is read against — the collection's own, unless {@link _scopedTo}. */
+    private _currentScope;
+    /**
+     * A view of this collection anchored to ONE scope — what `ISheet.getNames()` hands out.
+     *
+     * @remarks
+     * The collection a sheet inside a workbook is given IS the workbook's, whose current scope is
+     * whichever sheet the UI has selected. Anything resolved against that scope — `getByName`, and
+     * `getByRanges`'s qualification of unqualified coords — therefore answered about the sheet on
+     * SCREEN rather than the sheet the caller reached it through. Same call, same arguments, different
+     * answer depending on which tab was active.
+     *
+     * Reached through a sheet, the sheet IS the context, so bind it. Mirrors the identical fix on
+     * `Sheet.getCalculation`; `IWorkbook.getNames()` is unchanged and stays workbook-current.
+     *
+     * The anchor is the live sheet, not a captured name, so the view keeps working across a rename.
+     * Everything not scope-sensitive is bound straight through to the real instance — one memo, one
+     * subscription set, so a source's invalidation can never leave a view holding a stale result.
+     *
+     * `getItems` filters rather than re-queries, so the underlying memo still serves every sheet's
+     * view; the filter itself is a linear pass over the tens of items a workbook has.
+     */
+    _scopedTo(anchor: NamedCollection.Anchor): INamedCollection;
+    /** {@inheritDoc INamedCollection.getById} */
+    getById(id: string): INamed | null;
+    /**
+     * First source item satisfying `predicate`, preferring one scoped to `preferScope` over a
+     * global one — matching how the pushed store is keyed.
+     */
+    private _findInSources;
+    /**
+     * Source item whose name AND scope match exactly — the same identity the pushed store keys on.
+     *
+     * @remarks
+     * Unlike {@link _findInSources} there is no global fallback: `Total` and `Sheet1!Total` are
+     * distinct names, so a scoped query must not report the global one as a hit.
+     */
+    private _findInSourcesByKey;
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc INamedCollection.findValidName} */
+    findValidName(template: string, scope?: string | null, ignoreExisting?: boolean): string;
+    /** {@inheritDoc INamedCollection.validateName} */
+    validateName(named: string, scope?: string | null, ignoreExisting?: boolean): void;
+    _validateName(name: string, scope: string | null, ignoreExisting?: boolean): void;
+    /**
+     * {@inheritDoc INamedCollection.addFormula}
+     *
+     * @remarks
+     * Global. Asked of the WORKBOOK, "add a name" means a workbook name — deliberately NOT
+     * {@link _currentScope}, which follows the selected tab: reading against the sheet on screen is
+     * right for a query and would be a trap for a write, silently scoping a name to whichever tab
+     * happened to be active. `ISheet.getNames()` is where a scoped one comes from — see
+     * {@link _scopedTo}.
+     */
+    addFormula(name: string, expression: string, replaceExisting?: boolean): INamed;
+    /** {@link addFormula}, against an explicit `scope` — see {@link _scopedTo}. */
+    _addFormula(name: string, expression: string, replaceExisting?: boolean, scope?: string | null): INamed;
+    /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
+    beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+    /**
+     * Drops the memoized `getItems` result.
+     *
+     * @remarks
+     * Invoked for a local write AND for a source's `onCollectionChange` — the memo is keyed only on
+     * the query arguments, so anything that changes the underlying items has to clear it.
+     */
+    private _invalidateLookup;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: INamedCollection.IListeners, options?: IListener.Options): IListener.Remove;
+    isClosed(): boolean;
+    close(): void;
+    /**
+     * {@inheritDoc INamedCollection.isINamedCollection}
+     *
+     * @remarks
+     * A getter rather than a field so it survives {@link _scopedTo}: the proxy returns non-function
+     * properties straight through, which is what lets a sheet-scoped view be brand-checked like the
+     * real collection.
+     */
+    get isINamedCollection(): true;
+}
+/**
+ * {@inheritDoc NamedCollection}
+ */
+export declare namespace NamedCollection {
+    /**
+     * The sheet a {@link NamedCollection._scopedTo} view is anchored to — what "here" means for a query
+     * that does not say.
+     *
+     * @remarks
+     * Structural rather than `ISheet` to keep this module free of that import; a sheet satisfies it.
+     * Both members matter and for different reasons: `getName` is the scope a name resolves against,
+     * and `getRanges` is what a bare address like `'A1'` is read on.
+     */
+    interface Anchor {
+        getName(): string;
+        getRanges(address: ICellRanges.Address): ICellRanges | null;
+    }
+    /**
+     * A registry that contributes named items to the aggregating collection.
+     *
+     * @remarks
+     * `NamedCollection` is a pure aggregator: it owns nothing and queries its sources — defined names
+     * from the calculation engine, tables from their own collection, later shapes / charts / pictures.
+     * Each source keeps its own items; nothing is mirrored here, so there is only ever one copy of a
+     * name.
+     *
+     * **Pull data, push events.** {@link Source.getItems} is called on demand rather than cached, and
+     * {@link Source.addListeners} lets the aggregator invalidate and re-emit when a source changes.
+     *
+     * Deliberately minimal: a source returns everything it has and the aggregator does all filtering
+     * (by address, scope, type, hidden). Defined names number in the tens, so a linear scan beats
+     * making every source maintain a query surface — or a second index.
+     *
+     * Not on `INamedCollection`: how the aggregate is assembled is an implementation concern, and
+     * consumers only ever see the aggregate.
+     */
+    interface Source {
+        /**
+         * Every item this source contributes, unfiltered.
+         */
+        getItems(): readonly INamed[];
+        /**
+         * Notified when items are added, removed, renamed or re-scoped.
+         *
+         * @remarks
+         * The aggregator re-emits this as its own `onCollectionChange`, which is also what drops its
+         * lookup memo — a source changing behind a cached result is otherwise invisible.
+         */
+        addListeners(listeners: {
+            onCollectionChange?: (...args: any[]) => void;
+        }, options?: IListener.Options): IListener.Remove;
+        /**
+         * Creates a name owned by this source, if it can own one.
+         *
+         * @remarks
+         * Only the source that owns *defined names* implements this — the calculation engine. It backs
+         * {@link INamedCollection.addFormula}, so a name added through the workbook API lands in the
+         * same registry as one loaded from a file. A source of derived names (tables, and later shapes
+         * / charts) leaves it undefined; those are named by the thing they belong to.
+         */
+        add?(options: NamedCollection.AddNamedOptions): INamed;
+    }
+    /**
+     * What {@link Source.add} needs to define a name.
+     *
+     * @remarks
+     * Structurally a subset of the calculation engine's own add options, so
+     * `ICalculation.getNamedFormulas()` satisfies {@link Source} with no adapter.
+     */
+    interface AddNamedOptions {
+        name: string;
+        /** The expression the name is bound to. A plain range address is just a reference expression. */
+        expression: string;
+        scope?: string | null;
+        comment?: string;
+        hidden?: boolean;
+        /** Redefine an existing name in the same scope instead of throwing. */
+        replaceExisting?: boolean;
+    }
+    interface ConstructorOptions {
+        /**
+         * The registries this collection aggregates — see {@link Source}.
+         *
+         * @remarks
+         * A callback, not an array, because ownership is genuinely circular: the calculation engine
+         * takes this collection (it resolves table symbols through it), so it cannot exist when this
+         * is constructed. Resolving lazily lets the owner close the loop without a second wiring call.
+         *
+         * **Must tolerate being called before the other side exists.** It runs on every query and on
+         * `addListeners`, and the engine subscribes to this collection while it is still constructing —
+         * so the first call happens mid-cycle, by design. Return an empty array until ready; the next
+         * call picks the sources up.
+         *
+         * ```ts
+         * let workbook: IWorkbook;
+         * const names = new NamedCollection({
+         *   getSources: () => workbook ? [workbook.getCalculation().getNamedFormulas()] : [],
+         *   ...
+         * });
+         * workbook = new Workbook({ names });
+         * ```
+         *
+         * Re-invoked on each query and cheap to implement — the result is compared against the live
+         * subscriptions, and only an actual change re-subscribes.
+         */
+        getSources?: () => readonly NamedCollection.Source[];
+        /**
+         * Required to resolve ranges.
+         */
+        addressToRanges: (address: ICellRanges.Address) => ICellRanges;
+        /**
+         * Returns the current scope.
+         */
+        getCurrentScope?: () => string;
+        /**
+         * A transaction store that can be used to undo/redo changes to the names.
+         */
+        transactions?: ITransaction.IStore;
+        /**
+         * If the collection is readonly.
+         */
+        isReadOnly?: () => boolean;
+    }
+}
+//# sourceMappingURL=NamedCollection.d.ts.map

package/types/src/named/_BuiltInNamed.d.ts

@@ -0,0 +1,6 @@
+/** These all start with '_xlnm'. and are case-insensitive. */
+export declare const _BuiltInNamed: {
+    key: string;
+    description: string;
+}[];
+//# sourceMappingURL=_BuiltInNamed.d.ts.map

package/types/src/named/index.d.ts

@@ -0,0 +1,3 @@
+export * from './INamed';
+export * from './INamedCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/numFmt/BuiltInFormats.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ECMA-376 §18.8.30 built-in number formats (numFmtId -> format code).
+ *
+ * Engine-agnostic DATA shared by the format engines, IO (xlsx numFmtId
+ * round-trip), and the UI preset tables.
+ *
+ * Storage model styles STORE the numeric id when the format is a built-in
+ * (Excel's own model — styles.xml only writes ids >= 164) and a format-code
+ * string otherwise.
+ * Resolution to a code happens at the render/classification boundary via
+ * {@link resolveNumberFormat}.
+ */
+/**
+ * A number format reference: either an ECMA-376 built-in id (number) or a
+ * format-code string.
+ */
+export type NumberFormatRef = string | number;
+/** The first id available for custom formats (ids below are reserved built-ins). */
+export declare const FIRST_CUSTOM_FORMAT_ID = 164;
+export declare const BUILT_IN_FORMAT_CODES: Readonly<Record<number, string>>;
+/**
+ * Ids whose rendering adapts to the viewer's regional settings in Excel (the
+ * `*`-prefixed formats in the Format Cells dialog, currency symbol ids, and
+ * the regional/CJK 27-36 & 50-58 ranges).
+ *
+ * Today only 14/22 render adaptively (via the Intl interception in
+ * `toLocaleDateCore`); the rest resolve to their canonical en-US codes.
+ * I18N-DESIGN Plane 1 substitutes LocaleProfile-derived patterns here.
+ */
+export declare const LOCALE_ADAPTIVE_IDS: ReadonlySet<number>;
+/** The raw ECMA table lookup, or `undefined` for unknown ids. */
+export declare function getBuiltInFormatCode(id: number): string | undefined;
+/**
+ * Resolve a {@link NumberFormatRef} to a format-code string.
+ *
+ * Strings pass through; built-in ids resolve via the ECMA table (unknown ids
+ * resolve to `'General'`, matching Excel's behavior for unmapped ids).
+ *
+ * @remarks Locale-ADAPTIVE rendering of ids 14/22 is a value-level concern
+ * handled before engines format (see `toLocaleDateCore`) — this function
+ * always returns the canonical code.
+ */
+export declare function resolveNumberFormat(ref: NumberFormatRef): string;
+/**
+ * Find the built-in id for a format code (exact match, lowest id wins), or
+ * `undefined` if the code is not a built-in.
+ */
+export declare function findBuiltInFormatId(code: string): number | undefined;
+//# sourceMappingURL=BuiltInFormats.d.ts.map

package/types/src/numFmt/IFormatEngine.d.ts

@@ -0,0 +1,149 @@
+import { NumberFormatRef } from './BuiltInFormats';
+/**
+ * The number-format engine boundary.
+ *
+ * Everything that renders an Excel format code — cell rendering, commands,
+ * `TEXT()`, IO, clipboard — goes through this one interface.
+ */
+/** Options for {@link IFormatEngine.format}. */
+export interface FormatEngineOptions {
+    /**
+     * Use the 1904 date system.
+     * @defaultValue false
+     */
+    date1904?: boolean;
+    /**
+     * BCP-47 locale tag used for locale-dependent presets
+     * (`Short Date`, `[$-F800]`, ...).
+     * @defaultValue 'en-US'
+     */
+    locale?: string;
+    /**
+     * Collect fill/skip placeholders for width-aware cell rendering.
+     *
+     * When `true`:
+     * - `_x` (skip) and `?` (digit align) emit NOTHING into `text`; each records
+     *   a placeholder whose `char` is the width-reference character
+     *   (`'0'` for digit placeholders).
+     * - `*x` (fill) emits nothing and records a placeholder.
+     * - The section/conditional color is computed.
+     *
+     * When `false`/omitted (plain text output — TEXT(), clipboard, tooltips):
+     * - `_x` and `?` emit a single space; `*x` emits nothing.
+     * - `fills`/`skips`/`color` are `null`.
+     *
+     * @defaultValue false
+     */
+    placeholders?: boolean;
+}
+/**
+ * Structural metadata about a format code, for dialogs/classification.
+ * Mirrors numfmt's `getFormatInfo` (see {@link IFormatEngine.getFormatInfo}).
+ */
+export interface FormatInfo {
+    /** Coarse category: `general|number|grouped|currency|percent|scientific|fraction|date|time|datetime|text`. */
+    readonly type: string;
+    /** True if the format renders a date/time. */
+    readonly isDate: boolean;
+    /** True if the format is text-only (`@`). */
+    readonly isText: boolean;
+    /** True if the format scales by 100 and appends `%`. */
+    readonly isPercent: boolean;
+    /** Maximum number of decimal places any section emits. */
+    readonly maxDecimals: number;
+    /** Value multiplier implied by the format (e.g. 100 for percent, 0.001 for `#,##0,`). */
+    readonly scale: number;
+    /** Section color index, or 0. */
+    readonly color: number;
+    /** Non-zero if negatives are parenthesized. */
+    readonly parentheses: number;
+    /** Non-zero if the integer part is thousands-grouped. */
+    readonly grouped: number;
+}
+/** Which date/time components a format renders (numfmt `getFormatDateInfo`). */
+export interface FormatDateInfo {
+    readonly year: boolean;
+    readonly month: boolean;
+    readonly day: boolean;
+    readonly hours: boolean;
+    readonly minutes: boolean;
+    readonly seconds: boolean;
+    /** 12 or 24. */
+    readonly clockType: number;
+}
+/** A fill/skip position within {@link FormatEngineResult.text}. */
+export interface FormatPlaceholder {
+    /** Character offset into the result text. */
+    readonly offset: number;
+    /** The width-reference (skip) or repeated (fill) character. */
+    readonly char: string;
+}
+/** Result of {@link IFormatEngine.format}. */
+export interface FormatEngineResult {
+    /**
+     * The formatted display text, or `null` to signal a display error
+     * (e.g. an out-of-bounds date serial) — the cell renderer shows the
+     * `#` overflow placeholder for `null`.
+     */
+    readonly text: string | null;
+    /**
+     * The section/conditional color as a resolvable color string
+     * (e.g. `'Index9'` for legacy palette colors), or `null`.
+     * Only computed when {@link FormatEngineOptions.placeholders} is set.
+     */
+    readonly color: string | null;
+    /** `*` fill placeholders, or `null`. See {@link FormatEngineOptions.placeholders}. */
+    readonly fills: readonly FormatPlaceholder[] | null;
+    /** `_`/`?` skip placeholders, or `null`. See {@link FormatEngineOptions.placeholders}. */
+    readonly skips: readonly FormatPlaceholder[] | null;
+}
+/**
+ * A number-format engine. Stateless, and safe to share.
+ *
+ * Formats are {@link NumberFormatRef}s: either a format-code string or an
+ * ECMA-376 built-in id (the stored form for built-ins — Excel's own model).
+ * Ids are resolved AFTER the locale-adaptive interception (ids 14/22 render
+ * per the viewer locale, not their canonical codes).
+ */
+export interface IFormatEngine {
+    /** Stable identifier for diagnostics and conformance reports. */
+    readonly key: string;
+    /**
+     * Format a value with an Excel format code or built-in id.
+     *
+     * @throws On malformed/unsupported format codes — callers own the fallback
+     * policy (cell rendering warns and shows empty; conformance records it).
+     */
+    format(format: NumberFormatRef, value: string | number, options?: FormatEngineOptions): FormatEngineResult;
+    /** True if the format contains date tokens. */
+    isDateFormat(format: NumberFormatRef): boolean;
+    /** True if the format contains time tokens. */
+    isTimeFormat(format: NumberFormatRef): boolean;
+    /** True if the format contains fraction formatting. */
+    isFractionFormat(format: NumberFormatRef): boolean;
+    /**
+     * Adjust the decimal places in a format by `amount` (toolbar
+     * increase/decrease decimal). Returns the rewritten format code.
+     */
+    adjustDecimalPlaces(format: NumberFormatRef, amount: number): string;
+    /**
+     * Structural metadata for a format code (category, decimals, grouping, ...),
+     * for format dialogs and classification. `null` if the format is invalid.
+     */
+    getFormatInfo(format: NumberFormatRef): FormatInfo | null;
+    /**
+     * Which date/time components a (date) format renders. `null` for non-date
+     * formats or invalid codes.
+     */
+    getFormatDateInfo(format: NumberFormatRef): FormatDateInfo | null;
+    /** True if the format code parses (usable for live custom-code validation). */
+    isValidFormat(format: NumberFormatRef): boolean;
+}
+/**
+ * The number-format engine.
+ *
+ * Created on first use — this module sits in an import cycle with the engine's
+ * own helpers, so construction must not happen at module-evaluation time.
+ */
+export declare function getFormatEngine(): IFormatEngine;
+//# sourceMappingURL=IFormatEngine.d.ts.map

package/types/src/numFmt/NumberFormatBuilder.d.ts

@@ -0,0 +1,46 @@
+/** Top-level dialog categories (Date/Time group the Short/Medium/Long variants). */
+export type NumberFormatCategory = 'General' | 'Number' | 'Currency' | 'Accounting' | 'Date' | 'Time' | 'Percentage' | 'Fraction' | 'Scientific' | 'Text' | 'Special' | 'Custom';
+export declare const CATEGORIES: readonly NumberFormatCategory[];
+export declare function isParametricCategory(category: NumberFormatCategory): boolean;
+/** Parameters describing a number format for the dialog. */
+export interface NumberFormatParams {
+    category: NumberFormatCategory;
+    /** Number, Currency, Accounting, Percentage, Scientific. */
+    decimalPlaces?: number;
+    /** Number: thousands separator. */
+    useSeparator?: boolean;
+    /** Currency, Accounting: symbol literal (e.g. `$`). */
+    currencySymbol?: string;
+    /** Number, Currency: negative-number style index (see {@link NEGATIVE_STYLES}). */
+    negativeStyle?: number;
+    /** Date, Time, Fraction, Special, Custom: the chosen/typed format code. */
+    code?: string;
+}
+/**
+ * Negative-number presentation options (Number/Currency), matching Excel's list.
+ * The dialog renders a live sample per entry by building + formatting a negative.
+ */
+export declare const NEGATIVE_STYLES: readonly {
+    key: string;
+    label: string;
+    red: boolean;
+    parens: boolean;
+}[];
+/** Common currency symbols for the Currency/Accounting symbol picker. */
+export declare const CURRENCY_SYMBOLS: readonly string[];
+/** Preset code lists for the list categories (locale-adaptive later — Plane 1). */
+export declare const DATE_PRESETS: readonly string[];
+export declare const TIME_PRESETS: readonly string[];
+export declare const FRACTION_PRESETS: readonly string[];
+export declare const SPECIAL_PRESETS: readonly string[];
+/** Default code seeded when switching to a category. */
+export declare function defaultCodeForCategory(category: NumberFormatCategory): string;
+/** Synthesize an Excel format code from dialog parameters. */
+export declare function build(params: NumberFormatParams): string;
+/**
+ * Best-effort reverse of {@link build}: classify a code and recover the dialog
+ * controls. Round-trips stably for builder-produced codes; for arbitrary codes
+ * it lands on the closest category (Custom as the fallback).
+ */
+export declare function parse(code: string): NumberFormatParams;
+//# sourceMappingURL=NumberFormatBuilder.d.ts.map