@sheetxl/query 0.8.0-beta.1 → 0.8.0-beta.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/query",
   "description": "SheetXL - Workbook read surface and renderers (grep, reports) — capabilities declared once, adapted by any host surface",
-  "version": "0.8.0-beta.1",
+  "version": "0.8.0-beta.3",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -43,8 +43,8 @@
     "query"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.8.0-beta.1",
-    "@sheetxl/sdk": "^0.8.0-beta.1"
+    "@sheetxl/primitives": "^0.8.0-beta.3",
+    "@sheetxl/sdk": "^0.8.0-beta.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.2"

package/types/src/Tool.d.ts

@@ -104,5 +104,43 @@ export declare namespace Tool {
          */
         render(result: R): string | Promise<string>;
     }
+    /**
+     * A capability that reads the INSTALL rather than a workbook — the API reference.
+     *
+     * @remarks
+     * A separate shape rather than a {@link Descriptor} with an ignored argument, because what a
+     * surface wraps around a descriptor is exactly the part that does not apply: naming a workbook on
+     * a terminal, routing to a session over MCP. A reference answers the same with no workbook open
+     * and no session created, and a surface that demanded either would be asking for something the
+     * capability never reads.
+     *
+     * Everything else holds as it does for a descriptor: defined once, adapted mechanically, text
+     * agent-facing and English, defaults applied by the tool.
+     */
+    interface Reference<A = any, R = any> {
+        /** Tool name and subcommand — the same word on every surface. */
+        readonly name: string;
+        /** One or two lines, agent-facing, English. */
+        readonly description: string;
+        readonly params: readonly Param[];
+        run(args: A): Promise<R>;
+        /** The default agent-facing rendering of a result. */
+        render(result: R, options?: RenderOptions): string;
+    }
+    /**
+     * What a surface tells a renderer about itself.
+     */
+    interface RenderOptions {
+        /**
+         * How THIS surface spells the capability's own command — `sheetxl api`, `.api`. Defaults to the
+         * bare name, which is the spelling of a tool call.
+         *
+         * @remarks
+         * An answer that points at a follow-up ("everything on the type: …") is printing something to
+         * be typed, and the same capability is typed differently on each surface. This is the one
+         * affordance a renderer cannot work out for itself.
+         */
+        readonly command?: string;
+    }
 }
 //# sourceMappingURL=Tool.d.ts.map

package/types/src/api/apiTool.d.ts

@@ -0,0 +1,22 @@
+import { Tool } from '../Tool';
+import { ApiLookup } from './lookupApi';
+export interface ApiArgs {
+    name?: string;
+}
+/**
+ * Looks a name up in the scripting API — see {@link lookupApi} for what a name may be.
+ *
+ * @remarks
+ * A member answer carries its full declaration, sliced out of `scripting.d.ts` by the span the
+ * index recorded. That is the only lookup that reads the declarations at all: a type listing or a
+ * search is answered from the index alone, which is the point of having one.
+ *
+ * Declarations that cannot be read leave the member answer with its index line rather than failing
+ * it; the signature is still the answer to "how do I call this".
+ */
+export declare function describeApi(name?: string): Promise<ApiLookup.Result>;
+/**
+ * The API reference: what a script can call, from the declarations it is type-checked against.
+ */
+export declare const apiTool: Tool.Reference<ApiArgs, ApiLookup.Result>;
+//# sourceMappingURL=apiTool.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './lookupApi';
+export * from './renderApi';
+export * from './apiTool';
+//# sourceMappingURL=index.d.ts.map

package/types/src/api/lookupApi.d.ts

@@ -0,0 +1,127 @@
+import { ScriptingApi } from '@sheetxl/sdk';
+/**
+ * What a name resolved to in the scripting API index.
+ *
+ * @remarks
+ * One query string, four answers, decided by what the name matches — the caller never says which
+ * it wants. Nothing → the {@link ApiLookup.Overview}; a type → its members; `Type.member` → that
+ * member in full; anything else → a name {@link ApiLookup.Search}.
+ */
+export declare namespace ApiLookup {
+    /** A type {@link Type} extends, with where to read its members. */
+    interface Base {
+        /** As written in the `extends` clause, type arguments included. */
+        readonly text: string;
+        /** The index key it resolved to, or `null` for a type outside the index (`Iterable`, `Omit`). */
+        readonly key: string | null;
+        readonly memberCount: number;
+    }
+    interface Overview {
+        readonly kind: 'overview';
+        /** How many names the index holds. */
+        readonly total: number;
+        readonly entryPoints: readonly {
+            readonly key: string;
+            readonly entry: ScriptingApi.Entry;
+        }[];
+    }
+    interface Type {
+        readonly kind: 'type';
+        readonly key: string;
+        readonly entry: ScriptingApi.Entry;
+        readonly bases: readonly Base[];
+        /** The member substring the listing was narrowed by, when `Type.<text>` named no exact member. */
+        readonly filter?: string;
+        /** The entry's own members, narrowed by {@link filter} when present. */
+        readonly members: readonly ScriptingApi.Member[];
+    }
+    interface Member {
+        readonly kind: 'member';
+        /** The type that was asked about. */
+        readonly key: string;
+        /** The type that DECLARES the member — a base of {@link key} when the member is inherited. */
+        readonly declaredOn: string;
+        /** Every overload, in declaration order. */
+        readonly members: readonly ScriptingApi.Member[];
+        /**
+         * Each overload's full declaration, documentation included, parallel to {@link members}.
+         * Filled by the caller that has `scripting.d.ts` to slice; a lookup alone leaves it unset.
+         */
+        sources?: readonly string[];
+    }
+    interface Search {
+        readonly kind: 'search';
+        readonly query: string;
+        readonly types: readonly string[];
+        readonly members: readonly {
+            readonly key: string;
+            readonly member: ScriptingApi.Member;
+        }[];
+        /** Matches beyond the caps, not listed. */
+        readonly omitted: number;
+    }
+    type Result = Overview | Type | Member | Search;
+}
+/**
+ * The names an overview leads with — where a script's reach into a workbook starts.
+ *
+ * @remarks
+ * Advertising, not scope: every indexed name answers a lookup. These are the handful worth naming
+ * before the reader has asked for anything, in the order a script meets them.
+ */
+export declare const API_ENTRY_POINTS: readonly string[];
+/**
+ * Resolves a name against the scripting API index.
+ *
+ * @param name A type (`ICellRange`), a member (`ICellRange.setValues`), a word to search for, or
+ * nothing for the overview. A leading `SheetXL.` is accepted and ignored — it is how the name is
+ * written in a script, and a name copied out of one should resolve.
+ *
+ * @remarks
+ * `Type.text` is tried as a nested type first (`ICellRange.Coords` is its own entry), then as a
+ * member, inherited ones included. Text that names no member exactly narrows the type's listing to
+ * the members containing it — `ICellRange.merge` answers with every merge-related member rather
+ * than with "not found".
+ */
+export declare function lookupApi(index: ScriptingApi.Index, name?: string): ApiLookup.Result;
+/**
+ * The indexed type of a live SDK object, or `null` when it carries no brand the index knows.
+ *
+ * @remarks
+ * SDK objects answer `true` for an `isI<Name>` brand per interface they implement — the SDK's own
+ * convention for runtime type checks — so the brand names are the type names. An object usually
+ * carries several (a named range is an `INamedRange` AND an `ICellRange`); the most derived one
+ * wins, because its listing reaches the others through `extends` and the reverse is not true.
+ */
+export declare function apiTypeOf(index: ScriptingApi.Index, target: unknown): string | null;
+/**
+ * The `api` lookup that answers a compiler finding — `` `api ICellRanges` lists its members. `` —
+ * or `null` when the finding names no SDK type.
+ *
+ * @param message A TypeScript diagnostic, e.g. `Property 'getValues' does not exist on type 'ICellRanges'.`
+ * @param command How the host spells the lookup — `sheetxl api` in a terminal, `api` for a tool
+ * call. The line is there to be typed, so it has to be typeable where it is shown.
+ *
+ * @remarks
+ * A wrong member is the moment the listing is wanted: the finding names the receiver's type, and
+ * the type is the one thing the lookup needs. Only a plain capitalized name is taken — a union, a
+ * generic or a primitive is not something the index answers for.
+ */
+export declare function apiPointerFor(message: string, command: string): string | null;
+/**
+ * The members nearest a name the script used and the API does not have — the answer an `api`
+ * lookup would be asked for next, inline.
+ *
+ * @param message A compiler finding (`Property 'getFormat' does not exist on type 'ICellRange'.
+ * Did you mean 'getFormula'?`) or a run-time one (`r.getFormat is not a function`).
+ * @param command How the host spells the lookup, as for {@link apiPointerFor}.
+ *
+ * @remarks
+ * A compiler finding names the receiver, so its members are the candidates, TypeScript's own
+ * suggestion first. A run-time one names only the member, so every entry point's members are.
+ * A name another spreadsheet API uses for a concept SheetXL keeps elsewhere is answered with where
+ * (`getFormat` → the style). Returns `null` when nothing is near enough to be worth a line; the
+ * compiler finding's {@link apiPointerFor} still stands then.
+ */
+export declare function apiSuggestionsFor(index: ScriptingApi.Index, message: string, command: string): string | null;
+//# sourceMappingURL=lookupApi.d.ts.map

package/types/src/api/renderApi.d.ts

@@ -0,0 +1,13 @@
+import { Tool } from '../Tool';
+import { ApiLookup } from './lookupApi';
+/**
+ * Renders an API lookup as its agent-facing text.
+ *
+ * @remarks
+ * Every answer ends by naming the next lookup, and that line is there to be typed. So it is
+ * written the way the surface showing it spells the command ({@link Tool.RenderOptions.command}):
+ * `sheetxl api ICellRange` in a terminal, `.api ICellRange` in a session. One neutral spelling for
+ * all of them is wrong on most of them — `api IWorkbook` typed into a session is a syntax error.
+ */
+export declare function renderApi(result: ApiLookup.Result, options?: Tool.RenderOptions): string;
+//# sourceMappingURL=renderApi.d.ts.map

package/types/src/grep/GrepTypes.d.ts

@@ -1,5 +1,5 @@
 /**
- * The cell layers `grep` can match against.
+ * The layers `grep` can match against.
  *
  * @remarks
  * These are *not* `ICell.Content`. That enum also carries `formats`, `tables`, `merges` and
@@ -15,12 +15,14 @@
  * than a missing feature. Color wants *nearness*, not matching — that is selection by
  * attribute, and it belongs to the regions read.
  *
- * Two layers are deliberately absent for the same reason:
- * - `note` — `ICell.Content.Notes` is marked NOT IMPLEMENTED.
- * - `comment` — `IComment.Properties.content` is `any` pending `IRichText.JSON`, so any text
- *   extractor written against it today would quietly miss the shapes it did not anticipate.
+ * The rule does not stop at the cell. A callout, a chart title, a comment and a defined name are
+ * all text a person wrote into the workbook, and none of it is in any cell — so `comment`,
+ * `shape`, `chart` and `name` are layers too, tagged the same way. A search that finds the cell
+ * reading `Fund Size` and misses the callout explaining it has answered a narrower question than
+ * the one asked.
  *
- * Both are additive once the SDK shapes settle.
+ * There is no `note` field: a note is a comment that says so (`IComment.isNote`), and `comment`
+ * searches both.
  */
 export type GrepField = 
 /**
@@ -72,7 +74,38 @@ export type GrepField =
  * cells are percentages" — the rendered `40%` is not. Matches cells with a *direct*
  * format, including value-less ones (a formatted-but-empty column is a real finding).
  */
- | 'numberFormat';
+ | 'numberFormat'
+/**
+ * The comment or note on a cell, and every reply in its thread — each its own row.
+ *
+ * A cell layer like the others: the match is the commented cell, and a cell that matches in
+ * its display AND its comment is one cell. A comment on an empty cell is still found.
+ */
+ | 'comment'
+/**
+ * The text written on a shape — a text box, a callout — and its alt text.
+ *
+ * The match is the shape, addressed by the cells it is anchored over (`F2:H6`), which is what
+ * `range.getMovables()` takes to get back to it.
+ */
+ | 'shape'
+/**
+ * What a chart says in words: its title, its axis titles, the series names written into it,
+ * and its alt text. Addressed like a {@link GrepField | shape}.
+ *
+ * A series named by a cell (`=Sales!$C$3`) is not repeated here — that text is the cell's, and
+ * `display` already finds it there.
+ */
+ | 'chart'
+/**
+ * Defined names and tables: the name, what it refers to (`=Summary!$B$4`, `=0.21`) and its
+ * comment.
+ *
+ * The match is the name, spelled as a formula writes it (`'EU Ops'!Rate` when sheet-scoped) —
+ * a name has no cell of its own. Under a {@link GrepArgs.scope | scope} a name is searched
+ * when it is scoped to a searched sheet or designates cells inside the searched range.
+ */
+ | 'name';
 export declare const GrepField: {
     readonly Display: "display";
     readonly Value: "value";
@@ -80,6 +113,10 @@ export declare const GrepField: {
     readonly Formula: "formula";
     readonly Hyperlink: "hyperlink";
     readonly NumberFormat: "numberFormat";
+    readonly Comment: "comment";
+    readonly Shape: "shape";
+    readonly Chart: "chart";
+    readonly Name: "name";
 };
 /** Every field, in the order they are searched and reported. */
 export declare const GREP_FIELDS: readonly GrepField[];
@@ -93,6 +130,10 @@ export declare const GREP_FIELDS: readonly GrepField[];
  * carries new information — `1234.5678` behind `$1,234.57`. A duplicate hit costs an agent
  * a second look for no new information; a missing layer costs a silent zero-hit miss on
  * full-precision searches, which is worse.
+ *
+ * The layers off the grid are defaults by the same argument. A caller who has to ask for
+ * `shape` already knows the callout is there; the search that needs it is the one that does
+ * not. They cost one pass over a sheet's objects, not over its cells.
  */
 export declare const GREP_FIELDS_DEFAULT: readonly GrepField[];
 /** What a grep result should carry. */
@@ -134,9 +175,10 @@ export interface GrepArgs {
      */
     pattern: string;
     /**
-     * Which cell layers to search.
+     * Which layers to search.
      *
-     * @defaultValue {@link GREP_FIELDS_DEFAULT} — `['display', 'value', 'formula']`
+     * @defaultValue {@link GREP_FIELDS_DEFAULT} —
+     * `['display', 'value', 'formula', 'comment', 'shape', 'chart', 'name']`
      */
     fields?: readonly GrepField[];
     /**
@@ -166,11 +208,11 @@ export interface GrepArgs {
      */
     word?: boolean;
     /**
-     * Invert the match — report cells where **no** requested field matched (`rg -v`).
+     * Invert the match — report cells and objects where **no** requested field matched (`rg -v`).
      *
      * @remarks
-     * Scoped to cells grep visits: a cell must have text in at least one requested field to be
-     * reported (an empty cell is not a finding, and "every blank cell" is not an answer).
+     * Scoped to what grep visits: a cell or object must have text in at least one requested field
+     * to be reported (an empty cell is not a finding, and "every blank cell" is not an answer).
      * Reported rows carry the first requested field that has text, as the evidence line.
      */
     invert?: boolean;
@@ -200,14 +242,16 @@ export interface GrepArgs {
      */
     hidden?: boolean;
     /**
-     * Stop after this many matching cells. Truncation is always reported, never silent.
+     * Stop after this many matches — cells and objects together. Truncation is always reported,
+     * never silent.
      *
      * @defaultValue 200 — a grep result returns into a context window, not a terminal stream,
      * so unbounded output is a cost the caller did not ask for. `0` removes the cap.
      *
      * @remarks
-     * Counts **cells**, not match rows — a cell matching in two fields is one unit of budget.
-     * The search looks one cell past the cap, so a result that ends exactly at `maxCount` is
+     * Counts **cells and objects**, not match rows — a cell matching in two fields is one unit of
+     * budget, and so is a chart matching in its title and an axis.
+     * The search looks one match past the cap, so a result that ends exactly at `maxCount` is
      * only reported truncated when a further match actually exists.
      */
     maxCount?: number;
@@ -240,6 +284,10 @@ export interface GrepMatchContext {
  * order.
  *
  * @remarks
+ * Text that is not in a cell keeps the same shape. A shape or a chart is an entry per matched
+ * text, addressed by the cells it is anchored over, after its sheet's cells; a defined name is an
+ * entry addressed by the name itself, after every sheet.
+ *
  * Deliberately not coalesced into blocks: uniform runs of identical values are *regions* — a
  * payload feature splits where the value changes, so the regions read already owns that shape,
  * in 2-D and with the full partition to rank against. Grep answering cell-grain and regions
@@ -248,9 +296,15 @@ export interface GrepMatchContext {
  * renderer merely groups by it.
  */
 export interface GrepMatch {
-    /** Sheet name. */
+    /**
+     * Sheet name — for a `name` match, the sheet the name is scoped to, or `''` for a
+     * workbook-scoped one.
+     */
     sheet: string;
-    /** A1 cell address within the sheet. */
+    /**
+     * A1 cell address within the sheet; the anchor range (`F2:H6`) for a shape or chart; the name
+     * itself for a defined name. Qualified with `sheet`, each is something a follow-up call takes.
+     */
     address: string;
     /**
      * Which layer matched.
@@ -272,6 +326,8 @@ export interface GrepSheetMatches {
     sheet: string;
     /** Distinct cells that produced at least one match in this sheet. */
     cells: number;
+    /** Shapes and charts on this sheet that produced at least one match. */
+    objects: number;
 }
 /** The result of a {@link grep}. */
 export interface GrepResult {
@@ -283,6 +339,8 @@ export interface GrepResult {
     matches: readonly GrepMatch[];
     /** Distinct cells that produced at least one match. */
     cellCount: number;
+    /** Shapes, charts and names that produced at least one match. */
+    objectCount: number;
     /** Per-sheet counts, in search order — only sheets with at least one match appear. */
     sheets: readonly GrepSheetMatches[];
     /**

package/types/src/grep/grep.d.ts

@@ -1,9 +1,12 @@
 import { IWorkbook } from '@sheetxl/sdk';
 import { GrepArgs, GrepResult } from './GrepTypes';
 /**
- * Searches a workbook's cell contents by pattern.
+ * Searches a workbook's text by pattern — its cells, and what is written off the grid.
  *
  * @remarks
+ * Per sheet: the cells in reading order (a comment rides its cell), then the shapes and charts
+ * in reading order of their anchors. Defined names follow every sheet, since they belong to none.
+ *
  * Deliberately shaped after ripgrep — args, defaults and vocabulary are pretrained, and every
  * novel idiom is paid for in error loops.
  *

package/types/src/index.d.ts

@@ -2,6 +2,7 @@ import { Tool } from './Tool';
 export * from './Tool';
 export * from './encode';
 export * from './grep';
+export * from './api';
 export * from './markdown';
 /**
  * The read surface, defined once.
@@ -17,4 +18,12 @@ export * from './markdown';
  * reason). A capability joins this list only when it is not a one-line run idiom.
  */
 export declare const TOOLS: readonly Tool.Descriptor[];
+/**
+ * The reference surface — capabilities that read the install rather than a workbook.
+ *
+ * @remarks
+ * Registered by every host surface exactly as {@link TOOLS} is, minus the part that names a
+ * workbook. See {@link Tool.Reference}.
+ */
+export declare const REFERENCES: readonly Tool.Reference[];
 //# sourceMappingURL=index.d.ts.map

package/types/src/markdown/appendDependencies.d.ts

@@ -0,0 +1,106 @@
+import { ICellRange, ICellRanges, IRange, ISheet } from '@sheetxl/sdk';
+import { MarkdownBuilder } from './MarkdownBuilder';
+/**
+ * Options for the dependency sections.
+ */
+export interface AppendDependencyOptions {
+    /**
+     * Rows each tree prints before the rest of the graph is left to the flat call.
+     *
+     * @remarks
+     * A line budget, not a depth cut: the tree is filled level by level, so a budget that runs out
+     * drops the deepest nodes first, and every node with unshown children says how many.
+     *
+     * @defaultValue 12
+     */
+    maxTreeRows?: number;
+}
+/** The calculation-graph surface shared by {@link ICell}, {@link ICellRange} and a defined name. */
+export interface DependencySource {
+    getDirectPrecedents(): Promise<ICellRanges | null>;
+    getPrecedents(): Promise<ICellRanges | null>;
+    getDirectDependents(): Promise<ICellRanges | null>;
+    getDependents(): Promise<ICellRanges | null>;
+}
+/**
+ * How the caller wants empty sections and sheet crossings reported.
+ *
+ * @remarks
+ * Not a render option — these are facts about the SUBJECT that only the calling report knows. A
+ * formula cell with no dependents is an output and `Dependents (0)` says so; a text label with no
+ * dependents is just a label, and the same heading would be noise on every one of them.
+ */
+export interface DependencyContext {
+    /** Print `## Precedents (0)` rather than omitting the section. */
+    zeroPrecedents?: boolean;
+    /** Print `## Dependents (0)` rather than omitting the section. */
+    zeroDependents?: boolean;
+    /** The sheet the report is about; members elsewhere are listed as crossings. */
+    home?: ISheet | null;
+    /** The cells the report is about, when it is about cells: charts that plot them are dependents too. */
+    subject?: ICellRange | null;
+}
+/**
+ * Appends the `Precedents` and `Dependents` sections for anything that exposes the calculation
+ * graph — a cell, a range or a name, which answer the same questions with the same shape.
+ *
+ * @remarks
+ * **The heading carries the reach; the tree beneath shows the path.** The flat reach
+ * (`getPrecedents()` / `getDependents()`) is what the engine already holds for recalculation, so
+ * its size costs one call: `(239 cells · 216 inputs · depth 6 · 9 areas)`. That is the answer to
+ * the common question — how much does this read, how much reads it — without any code. The tree
+ * is the explanation, and it is budgeted by rows (see {@link AppendDependencyOptions.maxTreeRows}).
+ *
+ * `inputs` are the typed (non-formula) cells in the precedent reach — the values a change to the
+ * model is actually made in. `outputs` are the dependents nothing else reads — the reported
+ * figures a change here ends up in, which is why they are listed by address and row label.
+ *
+ * `depth` is the longest chain of hops, which is the number of levels the full tree would have.
+ * It is the one measure the engine does not hold, so it is a walk, bounded, and stated as a lower
+ * bound (`depth ≥ n`) when the bound fires.
+ */
+export declare function appendDependencies(md: MarkdownBuilder, target: DependencySource, options?: AppendDependencyOptions, context?: DependencyContext): Promise<void>;
+/**
+ * `row "Net Earnings" col "JUN"` — the labels of a single-cell node that is not itself text.
+ *
+ * @remarks
+ * `G33 21.7 =+G30-G32` does not say what G33 is; its labels do. Read with {@link findLabel}, so the
+ * rule is the cell report's. `origin` is the subject the tree hangs from: a label the node shares
+ * with it — the same row, the same column — is left off, since the reader already has it.
+ */
+export declare function describeNodeLabels(range: ICellRange, origin?: Readonly<IRange.Coords> | null): string;
+/**
+ * How a graph member LABELS itself: its address, the sheet it lives on, and whether it is a name.
+ *
+ * @remarks
+ * Shared by the tree and the flat {@link ICellRanges} listing, so the two cannot label the same
+ * member differently — the flat list is the tree's rows without the hop structure, and a reader
+ * comparing them is comparing the same text.
+ *
+ * A name member leads with its NAME: its address is only an anchor, and two names authored from
+ * the same cell would otherwise print as identical, anonymous cells.
+ *
+ * The address comes back **unqualified**. A listing standing on one sheet says so once, in its
+ * heading; a qualifier goes back on every row only when the collection spans sheets, which is the
+ * caller's decision because only the caller has seen every member. A trailing `!` is `#REF!`, not
+ * a qualifier, so it is left whole.
+ */
+export declare function describeNodeLabel(range: ICellRange): {
+    address: string;
+    sheet: string;
+    isName: boolean;
+};
+/**
+ * A node's payload: the value for a single cell, the size for a range.
+ *
+ * @remarks
+ * The whole point of walking as a tree rather than listing addresses — `1,204,880` beside
+ * `Model!O30` is what makes the chain readable as a model rather than as a set of coordinates.
+ * A formula node shows its expression too, because at that point the node explains itself.
+ *
+ * Shared with the flat {@link ICellRanges} listing (`renderRanges`) for the same reason
+ * {@link describeNodeLabel} is: the flat list is these rows without the hop structure, so the two
+ * shapes cannot be allowed to drift into describing one member two ways.
+ */
+export declare function describeNode(range: ICellRange): string;
+//# sourceMappingURL=appendDependencies.d.ts.map

package/types/src/markdown/appendPivotTables.d.ts

@@ -0,0 +1,22 @@
+import { IPivotTable } from '@sheetxl/sdk';
+import { MarkdownBuilder } from './MarkdownBuilder';
+/**
+ * Where a pivot table is laid out, as the address its markup declares — or `''`.
+ *
+ * @remarks
+ * Read from {@link IPivotTable.getXML} because the table has no model yet and that markup is the
+ * documented way to what it does not expose. The address is as the file wrote it: it does not
+ * follow rows and columns inserted since, which is the table's own stated limit and not this
+ * report's.
+ */
+export declare const describePivotLocation: (pivot: IPivotTable) => string;
+/**
+ * `## Pivot Tables (2)` over `  A3:D20  PivotTable1` rows.
+ *
+ * @remarks
+ * A pivot table's output is ordinary cells, so `Contentful` already lists the block — as numbers
+ * and labels, with nothing to say they are a summary of data held elsewhere and will be
+ * overwritten by the next refresh in Excel. This section is what says so.
+ */
+export declare function appendPivotTables(md: MarkdownBuilder, pivots: readonly IPivotTable[]): void;
+//# sourceMappingURL=appendPivotTables.d.ts.map