@heroiclands/package-build 22.15.1 → 22.17.0

package/types/content-config.d.mts

@@ -14,18 +14,21 @@ export function compilesFoundryDocuments(config: {
 /**
  * Whether this package publishes the pages its content tree compiles to.
  *
- * The one question every reader of the mode actually asks — the site build, to
- * decide whether to walk the tree at all, and the content index, to
- * decide whether an entry carries a web `path`. Written once here so the two
- * cannot come to disagree about what a mode means.
+ * Every package publishes an authored homepage. Other authored notes provide
+ * content pages; a tree containing only the homepage publishes only that page.
  *
- * @param {{publish: {site: SiteMode}}} config - A resolved configuration.
+ * Site, PDF, index, and Foundry address emission use the same source-tree
+ * decision. A file without note frontmatter is not a content page.
+ *
+ * @param {{paths: {content: string}, skipDirectories: readonly string[]}} config -
+ *   A resolved configuration with content and skip paths.
  * @returns {boolean} Whether content pages are published.
  */
 export function publishesContentPages(config: {
-    publish: {
-        site: SiteMode;
+    paths: {
+        content: string;
     };
+    skipDirectories: readonly string[];
 }): boolean;
 /**
  * Validate and normalize a content configuration.
@@ -123,44 +126,6 @@ export const RETIRED_ADDRESS_KEYS: Readonly<Record<string, string>>;
 export const DEFAULT_ADDRESS_SCHEME: Readonly<{
     prefix: "";
 }>;
-/**
- * How much of a package reaches the web.
- *
- * Every HeroicLands package publishes something: a top-level, human-authored
- * homepage at `https://www.heroiclands.org/<contentPackage>/` saying what the
- * module is, which system it needs and how to install it. So there is no
- * value here meaning *no web presence at all* — homepage-only is the **floor**,
- * and the default.
- *
- * - `homepage` — the authored homepage, and **no other page**. The content tree
- *   is not walked for pages, and nothing serves a page for its addresses.
- * - `content` — the homepage *plus* every page the content tree publishes, one
- *   per note.
- *
- * **Homepage-only is a first-class mode, not an accommodation.**
- * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'
- * Fan Material Guidelines) and `harn-adventures` (HârnFanon under Lythia's
- * terms) must each publish a homepage and nothing beneath it — two packages
- * under two different fan-content licences. The boundary is **published
- * content**: journal text, artwork, item descriptions, compiled notes. A
- * human-authored page announcing the module discloses none of it. Because the
- * failure mode is silent — a `site:` block added later ships licensed content
- * with nobody noticing — the mode fences the content surfaces off rather than
- * trusting a configuration to stay empty.
- *
- * This was a boolean until 5.0.0, and `false` read as "no web presence", which
- * no longer describes any package. Both spellings are refused rather than
- * mapped: a value silently reinterpreted reads to its author as though it still
- * means what it said.
- *
- * @typedef {"homepage" | "content"} SiteMode
- */
-/**
- * The publishing modes {@link PublishSwitches.site} may name, floor first.
- *
- * @satisfies {readonly SiteMode[]}
- */
-export const SITE_MODES: readonly ["homepage", "content"];
 /**
  * How the loader hands {@link defineConfig} the system version it resolved.
  *
@@ -189,37 +154,6 @@ export const DERIVED_SYSTEM_VERSION: symbol;
  * @type {Readonly<Record<string, string>>}
  */
 export const DERIVED_HUGO_KEYS: Readonly<Record<string, string>>;
-/**
- * How much of a package reaches the web.
- *
- * Every HeroicLands package publishes something: a top-level, human-authored
- * homepage at `https://www.heroiclands.org/<contentPackage>/` saying what the
- * module is, which system it needs and how to install it. So there is no
- * value here meaning *no web presence at all* — homepage-only is the **floor**,
- * and the default.
- *
- * - `homepage` — the authored homepage, and **no other page**. The content tree
- *   is not walked for pages, and nothing serves a page for its addresses.
- * - `content` — the homepage *plus* every page the content tree publishes, one
- *   per note.
- *
- * **Homepage-only is a first-class mode, not an accommodation.**
- * `sohl-kethira-basic` (unofficial Hârn fan material under Keléstia Productions'
- * Fan Material Guidelines) and `harn-adventures` (HârnFanon under Lythia's
- * terms) must each publish a homepage and nothing beneath it — two packages
- * under two different fan-content licences. The boundary is **published
- * content**: journal text, artwork, item descriptions, compiled notes. A
- * human-authored page announcing the module discloses none of it. Because the
- * failure mode is silent — a `site:` block added later ships licensed content
- * with nobody noticing — the mode fences the content surfaces off rather than
- * trusting a configuration to stay empty.
- *
- * This was a boolean until 5.0.0, and `false` read as "no web presence", which
- * no longer describes any package. Both spellings are refused rather than
- * mapped: a value silently reinterpreted reads to its author as though it still
- * means what it said.
- */
-export type SiteMode = "homepage" | "content";
 export type PackageKind = "systems" | "modules" | "documentation";
 export type PackDocumentType = "Actor" | "Adventure" | "Item" | "JournalEntry" | "Macro" | "Scene";
 /**
@@ -416,10 +350,11 @@ export type StatsSpec = {
 export type PackageBuildSection = Record<string, unknown>;
 export type PublishSwitches = {
     /**
-     * How much of this package reaches the web.
-     * See {@link SITE_MODES}.
+     * Where content pages mount within the package.
      */
-    site: SiteMode;
+    address: Readonly<{
+        prefix: string;
+    }>;
 };
 /**
  * The **Foundry core** version range this package supports.
@@ -554,13 +489,12 @@ export type DocPageSpec = {
 export type DocsSpec = {
     /**
      * The item-frontmatter reference,
-     *   rendered by `content-build docs
+     *   rendered by `package-build docs
      *   item-fields`.
      */
     itemFields?: DocPageSpec | undefined;
 };
 export type PublishSwitchesInput = {
-    site?: SiteMode | undefined;
     address?: AddressSchemeInput | undefined;
 };
 export type AddressSchemeInput = {

package/types/engine/address-render.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Render the four segments of a complete Address in lowercase.
+ * @param {{package: string, system: string, type: string, shortcode: string}} tuple
+ * @returns {string} The canonical Address.
+ */
+export function renderAddress(tuple: {
+    package: string;
+    system: string;
+    type: string;
+    shortcode: string;
+}): string;
+/** Render every written suffix of one complete Address. */
+export function addressSuffixes(tuple: any): string[];

package/types/engine/address.d.mts

@@ -112,16 +112,6 @@ export function parseAddress(written: unknown, defaults?: AddressDefaults, { dec
  * @returns {boolean} Whether it is a typed tuple.
  */
 export function isAddressTuple(value: unknown): boolean;
-/**
- * Render a complete Address as its canonical string.
- *
- * Lowercased, because an Address has one spelling: two names differing only in
- * case are two names nobody can tell apart.
- *
- * @param {AddressTuple} tuple - The complete Address.
- * @returns {string} `package-system-type-shortcode`.
- */
-export function renderAddress(tuple: AddressTuple): string;
 /**
  * Whether the canonical type an Address names is accepted at this position.
  *
@@ -278,7 +268,6 @@ export function readQualifier(target: string, types: Set<string>, packages?: Set
     system?: string;
     reason?: undefined;
 } | AddressProblem | null;
-export { NO_SYSTEM };
 /**
  * The one character that separates an Address's segments.
  *
@@ -381,3 +370,5 @@ export type AddressDefaults = AddressVocabulary & {
     type?: string;
 };
 import { NO_SYSTEM } from "./systems.mjs";
+import { renderAddress } from "./address-render.mjs";
+export { NO_SYSTEM, renderAddress };

package/types/engine/anchors.d.mts

@@ -1,9 +1,8 @@
 /**
- * The `{#slug}` anchors a note's body declares, with where each one sits.
+ * The `{#slug}` and `:::caption {#slug}` anchors a note declares.
  *
- * Only headings carrying an explicit anchor are collected. A bare `#` heading
- * also starts a journal page, but it declares no slug, so nothing can address
- * it with `#…` — listing it would offer a link that cannot be written.
+ * A bare `#` heading starts a journal page without declaring a slug. Captioned
+ * blocks declare a slug and start an addressable journal page.
  *
  * @param {string} body - The note's markdown body, frontmatter already removed.
  * @param {number} [bodyLine] - The 1-based file line the body starts on, from

package/types/engine/asset-bindings.d.mts

@@ -1,5 +1,12 @@
-/** Check configured foreign Address bindings against fetched indexes. */
-export function checkForeignAssetBindings(config: any, { foreignIndex, assets }?: {}): {
+/**
+ * Check configured foreign Address bindings against fetched indexes.
+ * @param {object} config
+ * @param {{foreignIndex?: Map<string, object>, assets?: object[]}} [options]
+ */
+export function checkForeignAssetBindings(config: object, { foreignIndex, assets }?: {
+    foreignIndex?: Map<string, object>;
+    assets?: object[];
+}): {
     file: string;
     severity: string;
     message: string;

package/types/engine/base-compiler.d.mts

@@ -376,7 +376,6 @@ export class BasePackCompiler {
     prepare(): Promise<void>;
     reportsCorpusProblems: boolean | undefined;
     linkIndex: any;
-    contentDocs: any;
     sqlTables: any;
     worldPresent: unknown;
     /**
@@ -478,7 +477,7 @@ export class BasePackCompiler {
      * a line rather than at a note.
      *
      * Silent where nothing can answer — no published schema, or a subtype the
-     * artifact does not name. `content-build lint` says that out loud once for
+     * artifact does not name. `package-build lint` says that out loud once for
      * the whole build rather than once per note.
      *
      * @param {object} fm - The note's frontmatter.

package/types/engine/being-measurements.d.mts

@@ -0,0 +1,16 @@
+/** Read a being's height as a whole number of inches. */
+export function parseBeingHeight(value: any): number | null;
+/** Read a being's weight as a whole number of pounds. */
+export function parseBeingWeight(value: any): number | null;
+/** Show a being's height in feet and inches. */
+export function displayBeingHeight(value: any): string;
+/** Show a being's weight in pounds. */
+export function displayBeingWeight(value: any): string;
+/** Check one authored being measurement at its frontmatter position. */
+export function checkBeingMeasurement(note: any, key: any, parse: any): {
+    severity: string;
+    message: string;
+    line?: number;
+    column?: number;
+    file?: any;
+}[];

package/types/engine/calendar-choice.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Require a being's or place's chosen calendar to address a calendar note.
+ * @param {object} note
+ * @param {{index?: object}} [options]
+ */
+export function checkCalendarChoice(note: object, { index }?: {
+    index?: object;
+}): {
+    severity: string;
+    message: string;
+    line?: number;
+    column?: number;
+    file: any;
+}[];

package/types/engine/calendar-format.d.mts

@@ -0,0 +1,33 @@
+/** Brackets and braces must close; `[[]` is a literal left bracket. */
+export function calendarFormatSyntaxError(pattern: any): string | null;
+/** Split a Calendaria pattern into tokens and literal text. */
+export function calendarFormatSegments(pattern: any): {
+    token: boolean;
+    value: any;
+}[];
+/** A standard format must identify one calendar day and be readable without context. */
+export function readableCalendarFormatError(pattern: any): string | null;
+/** Whether a selected pattern prints clock components. */
+export function calendarFormatHasClock(pattern: any): boolean;
+/** Keep the fields named by an authored date's precision. */
+export function calendarPatternSegmentsForPrecision(pattern: any, precision?: string, includeClock?: boolean): {
+    token: boolean;
+    value: any;
+}[];
+/** Choose an authored named format, with `std` as the preferred default. */
+export function selectCalendarFormat(calendar: any, name: any): {
+    name: any;
+    pattern: any;
+};
+/** Format calendar date components with Calendaria's documented tokens. */
+export function formatCalendarPattern(pattern: any, parts: any, precision?: string, includeClock?: boolean): string;
+/** Read the invertible date fields of one Calendaria pattern. */
+export function parseCalendarPattern(pattern: any, text: any, calendar: any): {
+    hour: number;
+};
+/** Convert a calendar month/day into its one-based day of year. */
+export function calendarOrdinal(calendar: any, month: any, day: any): number;
+/** Calendaria's bare date, time, week, season, and zone tokens. */
+export const CALENDAR_FORMAT_TOKENS: Readonly<Set<string>>;
+/** Calendaria's named fields inside brackets or braces. */
+export const CALENDAR_CUSTOM_TOKENS: Readonly<Set<string>>;

package/types/engine/calendar-human.d.mts

@@ -0,0 +1,4 @@
+/** The labels a human date may use to name one era. */
+export function eraNames(era: any): any[];
+/** Translate a named date into the addressed form read by the date parser. */
+export function addressedCalendarDate(text: any, eras: any): string | null;

package/types/engine/calendar-notes.d.mts

@@ -18,7 +18,7 @@ export function worldInvariants(index?: object): {
     yearNote: object | null;
     moonNote: object | null;
 };
-/** Check each authored format slot and every unescaped letter run in it. */
+/** Check each named pattern and the standard pattern's readable fields. */
 export function checkCalendarDateFormats(note: any): {
     severity: any;
     message: any;
@@ -101,12 +101,14 @@ export function quarterDays(daysPerYear: number): number[];
  * @param {string} [opts.contentPackage] - The package shipping the note, which
  *   is a fact about the tree rather than about the note: a note never declares
  *   its own package.
+ * @param {object} [opts.dateContext] - Calendar conversion context.
  * @returns {object} The definition.
  */
 export function compileCalendar({ note, invariants, contentPackage, dateContext }: {
     note: object;
     invariants: object;
     contentPackage?: string | undefined;
+    dateContext?: object | undefined;
 }): object;
 /**
  * Wrap a definition in the envelope a Calendaria settings import reads.
@@ -160,8 +162,7 @@ export const CALENDAR_SUBTYPE: "calendar";
 export const INVARIANT_SUBTYPES: readonly string[];
 /** Calendaria's display locations that a calendar note can format. */
 export const CALENDAR_DATE_FORMAT_KEYS: readonly string[];
-/** Bare date tokens Calendaria substitutes inside authored format strings. */
-export const CALENDAR_FORMAT_TOKENS: Readonly<Set<string>>;
+export { CALENDAR_FORMAT_TOKENS };
 /**
  * The `data:` keys a calendar note may write — the closed list, in authored
  * order.
@@ -183,3 +184,4 @@ export const CALENDAR_FIELDS: readonly object[];
  * @type {readonly object[]}
  */
 export const INVARIANT_FIELDS: readonly object[];
+import { CALENDAR_FORMAT_TOKENS } from "./calendar-format.mjs";

package/types/engine/calendars.d.mts

@@ -16,6 +16,8 @@
  * @returns {number} The signed year on the axis — authored `-1` is `0`.
  */
 export function canonicalYear(year: number, epoch?: number): number;
+/** The signed year a reckoning counts at a canonical year, without year zero. */
+export function eraYear(canonical: any, epoch?: number): number;
 /**
  * The total-order key a date sorts on.
  *
@@ -118,13 +120,13 @@ export function calendarStructure(calendar?: {
 /**
  * How long one month of a calendar is, or `null` where the calendar is silent.
  *
- * @param {{months?: readonly CalendarMonth[]|null}} [calendar] - The calendar.
+ * @param {{months?: readonly CalendarMonth[]|null}|undefined} calendar - The calendar.
  * @param {number} month - The month, numbered from 1.
  * @returns {number|null} Its length in days, or `null`.
  */
-export function daysInMonth(calendar?: {
+export function daysInMonth(calendar: {
     months?: readonly CalendarMonth[] | null;
-}, month: number): number | null;
+} | undefined, month: number): number | null;
 /**
  * How many days the months add up to.
  *

package/types/engine/code-fences.d.mts

@@ -1,45 +1,13 @@
 /**
- * A fence's info string, read as **org-babel header arguments**.
- *
- * A directive fence carries statements *about the directive* that are no part of
- * the query it holds — whether an empty result is intended, what heading level a
- * section takes, later a caption. Those started as an ad-hoc bare word
- * (`allow-empty`) and a `key=value` (`section-level=3`), each matched by its own
- * regex: a grammar only in the sense that two regexes are one, and with no room
- * to add a third property without adding a third spelling.
- *
- * Org-mode settled this long ago. A babel source block writes them after the
- * language as `:key value`, which is a real grammar with a specification, a
- * parser, and an editor that already completes it.
- *
- * ```text
- * ```sql :section-level 3 :allow-empty
- * ```
- *
- * **The language word stays first and stays plain.** `sql` is what GitHub,
- * Prettier and every other markdown reader match on to syntax-highlight the
- * block, so it leads and the header args follow; a reader that does not know
- * them sees an ordinary SQL block.
- *
- * The grammar, matching org's:
- *
- * - a key is `:name` **starting a word** — a colon inside or ending a word is
- *   text, so `:caption Gear: the tables` is one argument;
- * - a value runs to the next key or the end of the string, spaces included, and
- *   is trimmed;
- * - a key with no value is `true`, which is what a statement like
- *   `:allow-empty` is;
- * - a value may be `"quoted"` to hold a word that would otherwise read as a
- *   key — the one ambiguity org has too;
- * - a repeated key takes its last value.
- *
- * @param {string} info - The text after the fence marker.
- * @returns {{language: string, args: Record<string, string|true>}} The language,
- *   lowercased, and the header arguments in written order.
+ * Read a language name and optional braced attributes from a code fence.
+ * @param {string} info - Text after the fence marker.
+ * @returns {{language: string, args: Record<string, string>, problems: string[]}}
+ *   Parsed values and syntax findings.
  */
 export function parseHeaderArgs(info: string): {
     language: string;
-    args: Record<string, string | true>;
+    args: Record<string, string>;
+    problems: string[];
 };
 /**
  * Every code region in a markdown body, as character offsets into it.
@@ -107,39 +75,5 @@ export function matchAllOutsideCode(markdown: string, pattern: RegExp, options?:
  * @returns {string} The transformed body, with every code run restored verbatim.
  */
 export function protectCode(body: string, transform: (masked: string) => string): string;
-/**
- * Where **code** lives in a markdown body, so a rewriter can leave it alone.
- *
- * A code block is verbatim: its contents are shown to the reader exactly as
- * written. Every build-time rewriter that pattern-matches a body therefore has
- * to know where code is — otherwise a source listing that happens to contain
- * the rewriter's syntax is silently corrupted. Wikilink conversion met this as
- * `[[0]]` inside a fence being turned into a link, and it depended on
- * the surrounding literal's shape (`[[1,2],[3,4]]` survived), so the corruption
- * looked arbitrary.
- *
- * Three forms are recognised, which is every form the content tree uses:
- *
- * - **Fenced blocks** — three or more backticks or tildes, closed by the same
- *   character at least as long, or by the end of the document. A longer fence
- *   contains a shorter one, so a markdown sample can quote a code sample. The
- *   opening line, info string and all, is part of the block.
- * - **Indented blocks** — four columns past the enclosing context, following a
- *   blank line (an indent cannot interrupt a paragraph).
- * - **Inline spans** — a run of backticks closed by a run of equal length,
- *   within one paragraph.
- *
- * The fence syntax is the one `expandContentTables` already reads, and
- * this module owns it now so the two can never disagree.
- *
- * **Known limits.** This is a scanner, not a markdown parser, and it errs
- * towards treating something as code — a false positive leaves an author's text
- * as written, a false negative rewrites it. List nesting is tracked only to the
- * innermost open marker, so an indented block inside a deeply nested list may be
- * read as list prose; a backslash-escaped backtick still counts as a span
- * delimiter; and HTML blocks are not code (they are not verbatim in markdown
- * either). None of these can turn code into a link — the failure this exists to
- * prevent.
- */
 /** A fence line, capturing its indent, its marker, and its info string. */
 export const FENCE_LINE: RegExp;

package/types/engine/compile-corpus.d.mts

@@ -15,8 +15,7 @@
  *   created when none is passed, and returned on the corpus either way — a note
  *   the index refuses is a note the compile must still *report*, exactly as the
  *   compile loop reported it when the loop was the first to see it.
- * @returns {Promise<{records: object[], linkIndex: object, contentDocs: object[],
- *   sqlTables: Map<string, object[]>|undefined, problems: object[]}>} The corpus,
+ * @returns {Promise<{records: object[], linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[]}>} The corpus,
  *   its indexes, and the notes it could not record.
  */
 export function buildCompileCorpus({ contentBase, assetsBase, skipDirectories, router, config, problems, }: {
@@ -29,7 +28,6 @@ export function buildCompileCorpus({ contentBase, assetsBase, skipDirectories, r
 }): Promise<{
     records: object[];
     linkIndex: object;
-    contentDocs: object[];
     sqlTables: Map<string, object[]> | undefined;
     problems: object[];
 }>;

package/types/engine/content-admonitions.d.mts

@@ -0,0 +1,24 @@
+/** Find inline info and warning blocks without interpreting code examples. */
+export function scanAdmonitions(source: any): {
+    blocks: {
+        end: number;
+        body: string;
+        start: number;
+        kind: string;
+        id: string;
+    }[];
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+};
+/** Render info and warning blocks as styled, labelled HTML. */
+export function renderAdmonitions(source: any, renderMarkdown?: (src: string, env?: import("markdown-it").Env) => string): {
+    markdown: any;
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+};

package/types/engine/content-captions.d.mts

@@ -0,0 +1,45 @@
+/** Number a sequence of captions with counters shared across documents. */
+export function numberCaptions(captions: any, counts: any): any;
+/**
+ * Read caption directives and the Markdown block immediately after each one.
+ * SQL fences are expanded before this pass, so their output is a table.
+ *
+ * @param {string} source - A note body with expanded tables.
+ * @returns {{captions: Array<{id: string, text: string, kind: string, number: number,
+ *   label: string, line: number, blockStart: number, blockEnd: number,
+ *   directiveEnd: number}>, errors: Array<{line: number, column: number, message: string}>}}
+ */
+export function scanCaptions(source: string): {
+    captions: Array<{
+        id: string;
+        text: string;
+        kind: string;
+        number: number;
+        label: string;
+        line: number;
+        blockStart: number;
+        blockEnd: number;
+        directiveEnd: number;
+    }>;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/** Render captioned blocks as HTML, leaving other Markdown untouched. */
+export function renderCaptionBlocks(source: any, renderMarkdown: ((src: string, env?: import("markdown-it").Env) => string) | undefined, numbers: any): {
+    markdown: any;
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+};
+/** A caption's automatically determined kind. */
+export const CAPTION_NAMES: Readonly<{
+    code: "Code";
+    table: "Table";
+    figure: "Figure";
+    prose: "Prose";
+}>;

package/types/engine/content-footnotes.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Separate top-level footnote definitions from prose while retaining line numbers.
+ * Definitions belong to the note and can be used by any rendered page.
+ * @param {string} source - Authored Markdown.
+ * @returns {{markdown: string, definitions: string}} Body with blanked definitions and their source.
+ */
+export function separateFootnotes(source: string): {
+    markdown: string;
+    definitions: string;
+};

package/types/engine/content-format-check.d.mts

@@ -24,10 +24,17 @@ export function declaredPaths(artifact: object): Set<string>;
  * mappings" instead of "on a `weapongear`". Reading `on a \`the shared
  * mappings\`` would be the alternative, and a diagnostic is prose.
  *
- * @param {object} finding - `{system, systemVersion, noteType, source, target, shared}`.
+ * @param {{system: string, systemVersion: string, noteType: string, source: string, target: string, shared: boolean}} finding - The unresolved mapping.
  * @returns {string} The message.
  */
-export function undeclaredTargetMessage({ system, systemVersion, noteType, source, target, shared, }: object): string;
+export function undeclaredTargetMessage({ system, systemVersion, noteType, source, target, shared, }: {
+    system: string;
+    systemVersion: string;
+    noteType: string;
+    source: string;
+    target: string;
+    shared: boolean;
+}): string;
 /**
  * Check every `system.*` target the specification names.
  *
@@ -101,10 +108,16 @@ export function measureCorpus(notes: Iterable<object>, format: import("./content
 /**
  * What an author is told when the specification and the declaration disagree.
  *
- * @param {object} finding - `{noteType, source, target, name, to}`.
+ * @param {{noteType: string, source: string, target: string, name: string, to: string}} finding - The differing mapping.
  * @returns {string} The message.
  */
-export function fieldDriftMessage({ noteType, source, target, name, to }: object): string;
+export function fieldDriftMessage({ noteType, source, target, name, to }: {
+    noteType: string;
+    source: string;
+    target: string;
+    name: string;
+    to: string;
+}): string;
 /**
  * The declaration that compiles one mapping row, and what is left over.
  *