confluence-md-sync 0.1.1

package/dist/macros/registry.js

@@ -0,0 +1,111 @@
+import { Markdown } from '../markdown/markdown.js';
+import { unescapeParamValue } from './builder.js';
+import { generateMacroId } from './xml.js';
+/**
+ * Реестр макросов. Пустой при создании — наполняется плагинами через
+ * {@link use} или точечной регистрацией через {@link register}.
+ *
+ * @example
+ *   const registry = new MacroRegistry()
+ *     .use(coreMacrosPlugin)
+ *     .use(tableFilterPlugin)
+ *     .register('my-macro', (ctx) => `<ac:structured-macro ...>`);
+ */
+export class MacroRegistry {
+    renderers = new Map();
+    pluginNames = [];
+    /** Registers all macros of a plugin. Later registrations win on name clash. */
+    use(plugin) {
+        for (const def of plugin.macros) {
+            this.renderers.set(def.name, def.render);
+        }
+        this.pluginNames.push(plugin.name);
+        return this;
+    }
+    register(name, renderer) {
+        this.renderers.set(name, renderer);
+        return this;
+    }
+    has(name) {
+        return this.renderers.has(name);
+    }
+    getRenderer(name) {
+        return this.renderers.get(name);
+    }
+    getAllRenderers() {
+        return this.renderers;
+    }
+    /** Names of plugins registered via {@link use} (for diagnostics). */
+    get plugins() {
+        return [...this.pluginNames];
+    }
+}
+/**
+ * Преобразует маркеры макросов в XHTML storage format.
+ * Обрабатывает вложенные макросы снизу вверх (от inner к outer).
+ */
+export function processMacros(storage, registry) {
+    let content = storage instanceof Markdown ? storage.toString() : storage;
+    // Повторяем, пока есть макросы (для обработки вложения)
+    let modified = true;
+    let iterations = 0;
+    const maxIterations = 100;
+    while (modified && iterations < maxIterations) {
+        modified = false;
+        iterations++;
+        for (const [macroName, renderer] of registry.getAllRenderers()) {
+            const result = processMacroType(content, macroName, renderer);
+            if (result !== content) {
+                content = result;
+                modified = true;
+                break;
+            }
+        }
+    }
+    return new Markdown(content);
+}
+function processMacroType(storage, macroName, renderer) {
+    // `:[^\n]*?` — lazy до конца строки маркера. Раньше тут было `[^-]*`,
+    // что ломалось на дефис в имени параметра (например cell-width=) или
+    // в значении: маркер целиком не матчился и макрос не рендерился.
+    const startMarkerRe = new RegExp(`<!-- MACRO:start:${escapeRegex(macroName)}(:[^\\n]*?)? -->`, 'g');
+    let match;
+    while ((match = startMarkerRe.exec(storage)) !== null) {
+        const paramStr = match[1] ?? '';
+        const params = parseParams(paramStr);
+        const startIdx = match.index;
+        const endMarker = `<!-- MACRO:end:${macroName} -->`;
+        const endIdx = storage.indexOf(endMarker, startIdx);
+        if (endIdx === -1) {
+            console.warn(`[macro] start marker without end for macro '${macroName}' at position ${startIdx}`);
+            continue;
+        }
+        const bodyStart = startIdx + match[0].length;
+        const body = storage.substring(bodyStart, endIdx).trim();
+        const macroId = generateMacroId();
+        const macroXhtml = renderer({ params, body, macroId });
+        const before = storage.substring(0, startIdx);
+        const after = storage.substring(endIdx + endMarker.length);
+        storage = before + macroXhtml + after;
+        // Сбрасываем поиск для повторной обработки
+        startMarkerRe.lastIndex = 0;
+    }
+    return storage;
+}
+function parseParams(paramStr) {
+    if (!paramStr.trim())
+        return [];
+    return paramStr
+        .split(':')
+        .filter((p) => p.trim())
+        .map((pair) => {
+        const [name, value] = pair.split('=');
+        return {
+            name: unescapeParamValue(name?.trim() ?? ''),
+            value: unescapeParamValue(value?.trim() ?? ''),
+        };
+    });
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/macros/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Core types of the pluggable macro system.
+ *
+ * Макросы в markdown представлены как комментарии:
+ *   <!-- MACRO:start:name:param1=value1:param2=value2 -->
+ *   markdown content / nested macros
+ *   <!-- MACRO:end:name -->
+ *
+ * После рендера в storage format эти маркеры преобразуются в
+ * <ac:structured-macro> с соответствующими параметрами.
+ */
+export interface MacroParam {
+    name: string;
+    value: string;
+}
+export interface RendererContext {
+    params: MacroParam[];
+    /** Macro body already rendered to XHTML (may contain nested rendered macros). */
+    body: string;
+    /** Generated UUID for ac:macro-id. */
+    macroId: string;
+}
+/** Renders a macro marker into Confluence storage-format XHTML. */
+export type MacroRenderer = (ctx: RendererContext) => string;
+export interface MacroDefinition {
+    name: string;
+    render: MacroRenderer;
+}
+/**
+ * A plugin is a named collection of macro definitions. Register it on a
+ * {@link MacroRegistry} via `registry.use(plugin)`.
+ */
+export interface MacroPlugin {
+    name: string;
+    macros: MacroDefinition[];
+}
+/** Convenience: turn `params` array into a name→value map. */
+export declare function paramMap(params: MacroParam[]): Record<string, string>;

package/dist/macros/types.js

@@ -0,0 +1,15 @@
+/**
+ * Core types of the pluggable macro system.
+ *
+ * Макросы в markdown представлены как комментарии:
+ *   <!-- MACRO:start:name:param1=value1:param2=value2 -->
+ *   markdown content / nested macros
+ *   <!-- MACRO:end:name -->
+ *
+ * После рендера в storage format эти маркеры преобразуются в
+ * <ac:structured-macro> с соответствующими параметрами.
+ */
+/** Convenience: turn `params` array into a name→value map. */
+export function paramMap(params) {
+    return Object.fromEntries(params.map((p) => [p.name, p.value]));
+}

package/dist/macros/xml.d.ts

@@ -0,0 +1,28 @@
+/** XML helpers shared by macro renderers. */
+import type { MacroParam } from './types.js';
+/** Экранирует строку для XML-атрибутов и текстовых узлов. */
+export declare function escapeXmlAttr(s: string): string;
+/** Генерирует UUID для ac:macro-id. */
+export declare function generateMacroId(): string;
+export interface StructuredMacroOptions {
+    /**
+     * Macro parameters. `undefined` values are skipped. A key rendered as
+     * empty string (`''`) produces `<ac:parameter ac:name="">` — some
+     * built-in macros (anchor, include) use the unnamed parameter.
+     * Values are escaped unless wrapped in {@link rawValue}.
+     */
+    params?: Array<MacroParam & {
+        raw?: boolean;
+    }>;
+    /** Rich text body (already-rendered XHTML). */
+    richBody?: string;
+    /** Plain text body — wrapped in CDATA (for `code`, `noformat`, etc.). */
+    plainBody?: string;
+}
+/**
+ * Assembles an `<ac:structured-macro>` element. Takes care of parameter
+ * escaping, rich vs plain bodies and CDATA safety.
+ */
+export declare function structuredMacro(name: string, macroId: string, opts?: StructuredMacroOptions): string;
+/** Builds an `<ac:link><ri:page .../></ac:link>` value for page-reference params. */
+export declare function pageLinkValue(title: string, spaceKey?: string): string;

package/dist/macros/xml.js

@@ -0,0 +1,52 @@
+/** XML helpers shared by macro renderers. */
+/** Экранирует строку для XML-атрибутов и текстовых узлов. */
+export function escapeXmlAttr(s) {
+    return s.replace(/[<>&"']/g, (c) => {
+        switch (c) {
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '&': return '&amp;';
+            case '"': return '&quot;';
+            case "'": return '&apos;';
+            default: return c;
+        }
+    });
+}
+/** Генерирует UUID для ac:macro-id. */
+export function generateMacroId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Assembles an `<ac:structured-macro>` element. Takes care of parameter
+ * escaping, rich vs plain bodies and CDATA safety.
+ */
+export function structuredMacro(name, macroId, opts = {}) {
+    const params = (opts.params ?? [])
+        .map((p) => {
+        const value = p.raw ? p.value : escapeXmlAttr(p.value);
+        return `<ac:parameter ac:name="${escapeXmlAttr(p.name)}">${value}</ac:parameter>`;
+    })
+        .join('');
+    let body = '';
+    if (opts.plainBody !== undefined) {
+        // `]]>` внутри CDATA недопустим — разрезаем на соседние CDATA-секции.
+        const safe = opts.plainBody.replace(/\]\]>/g, ']]]]><![CDATA[>');
+        body = `<ac:plain-text-body><![CDATA[${safe}]]></ac:plain-text-body>`;
+    }
+    else if (opts.richBody !== undefined) {
+        body = `<ac:rich-text-body>${opts.richBody}</ac:rich-text-body>`;
+    }
+    return (`<ac:structured-macro ac:name="${escapeXmlAttr(name)}" ac:schema-version="1" ac:macro-id="${escapeXmlAttr(macroId)}">` +
+        params +
+        body +
+        `</ac:structured-macro>`);
+}
+/** Builds an `<ac:link><ri:page .../></ac:link>` value for page-reference params. */
+export function pageLinkValue(title, spaceKey) {
+    const space = spaceKey ? ` ri:space-key="${escapeXmlAttr(spaceKey)}"` : '';
+    return `<ac:link><ri:page ri:content-title="${escapeXmlAttr(title)}"${space}/></ac:link>`;
+}

package/dist/markdown/markdown.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Типизированное представление Markdown контента с валидацией.
+ *
+ * Вместо обычных строк используется класс Markdown для:
+ * - Явности типа в сигнатурах функций
+ * - Валидации содержимого (незакрытые макросы, неверные плейсхолдеры)
+ * - Удобства преобразований и композиции
+ */
+export declare class Markdown {
+    private readonly content;
+    constructor(content: string);
+    /**
+     * Валидирует markdown контент.
+     *
+     * Проверяет:
+     * - Закрытость всех макросов (MACRO:start/end)
+     * - Корректность плейсхолдеров таблиц
+     */
+    private validate;
+    private validateMacros;
+    private validateTablePlaceholders;
+    /** Возвращает строковое представление. */
+    toString(): string;
+    /** Возвращает длину контента. */
+    get length(): number;
+    /** Проверяет, содержит ли контент таблицы. */
+    hasTables(): boolean;
+    /** Извлекает все имена плейсхолдеров таблиц. */
+    getTableNames(): string[];
+    /** Создаёт Markdown из строки. */
+    static from(content: string): Markdown;
+    /** Объединяет несколько Markdown в один. */
+    static concat(...parts: (Markdown | string)[]): Markdown;
+    /** Пустой Markdown. */
+    static empty(): Markdown;
+}

package/dist/markdown/markdown.js

@@ -0,0 +1,78 @@
+/**
+ * Типизированное представление Markdown контента с валидацией.
+ *
+ * Вместо обычных строк используется класс Markdown для:
+ * - Явности типа в сигнатурах функций
+ * - Валидации содержимого (незакрытые макросы, неверные плейсхолдеры)
+ * - Удобства преобразований и композиции
+ */
+export class Markdown {
+    content;
+    constructor(content) {
+        this.validate(content);
+        this.content = content;
+    }
+    /**
+     * Валидирует markdown контент.
+     *
+     * Проверяет:
+     * - Закрытость всех макросов (MACRO:start/end)
+     * - Корректность плейсхолдеров таблиц
+     */
+    validate(content) {
+        this.validateMacros(content);
+        this.validateTablePlaceholders(content);
+    }
+    validateMacros(content) {
+        const startMarkers = (content.match(/<!-- MACRO:start:/g) || []).length;
+        const endMarkers = (content.match(/<!-- MACRO:end:/g) || []).length;
+        if (startMarkers !== endMarkers) {
+            throw new Error(`Markdown validation failed: mismatched macro markers (start: ${startMarkers}, end: ${endMarkers})`);
+        }
+    }
+    validateTablePlaceholders(content) {
+        const placeholders = Array.from(content.matchAll(/\{\{table:([a-z0-9_-]+)\}\}/gi));
+        if (placeholders.length === 0)
+            return;
+        const seen = new Set();
+        for (const [, name] of placeholders) {
+            if (seen.has(name.toLowerCase())) {
+                throw new Error(`Markdown validation failed: duplicate table placeholder '{{table:${name}}}'`);
+            }
+            seen.add(name.toLowerCase());
+        }
+    }
+    /** Возвращает строковое представление. */
+    toString() {
+        return this.content;
+    }
+    /** Возвращает длину контента. */
+    get length() {
+        return this.content.length;
+    }
+    /** Проверяет, содержит ли контент таблицы. */
+    hasTables() {
+        return /\{\{table:/.test(this.content);
+    }
+    /** Извлекает все имена плейсхолдеров таблиц. */
+    getTableNames() {
+        const names = new Set();
+        for (const [, name] of this.content.matchAll(/\{\{table:([a-z0-9_-]+)\}\}/gi)) {
+            names.add(name.toLowerCase());
+        }
+        return Array.from(names);
+    }
+    /** Создаёт Markdown из строки. */
+    static from(content) {
+        return new Markdown(content);
+    }
+    /** Объединяет несколько Markdown в один. */
+    static concat(...parts) {
+        const content = parts.map((p) => (p instanceof Markdown ? p.toString() : p)).join('');
+        return new Markdown(content);
+    }
+    /** Пустой Markdown. */
+    static empty() {
+        return new Markdown('');
+    }
+}

package/dist/markdown/render.d.ts

@@ -0,0 +1,35 @@
+export declare const PLACEHOLDER_RE: RegExp;
+export interface ExtractedPlaceholders {
+    images: string[];
+    files: string[];
+}
+export declare function extractPlaceholders(markdown: string): ExtractedPlaceholders;
+export interface AttachmentUrls {
+    /** filename → абсолютный URL аттача, полученный из Confluence после аплоада. */
+    images: Map<string, string>;
+    files: Map<string, string>;
+}
+export declare class MissingAttachmentUrlError extends Error {
+    constructor(message: string);
+}
+/**
+ * Превращает Markdown в Confluence storage format.
+ *
+ * Логика двушаговая:
+ *   1) markdown-it рендерит сам Markdown (без знания про плейсхолдеры).
+ *      `{{img:foo}}` и `{{file:foo}}` для markdown-it — обычный текст
+ *      без спецсимволов, доходят до выхода нетронутыми (могут быть
+ *      обёрнуты в <p>...</p>, что нас устраивает).
+ *   2) В готовом HTML регуляркой подставляем `<img src=URL/>` и
+ *      `<a href=URL>filename</a>` на места плейсхолдеров. URL обязан
+ *      существовать для каждого плейсхолдера — иначе
+ *      MissingAttachmentUrlError.
+ *
+ * Раньше использовалась схема через sentinel-токены (` CFLIMG_0 `):
+ * markdown-it трогал окружающие пробелы при упаковке в <p>, sentinel
+ * терял пробелы, итоговый .split() не находил совпадения и в Confluence
+ * вместо картинки попадал кусок «CFLIMG_0». Прямая регекс-замена по
+ * HTML этой проблемы лишена — `{{img:foo}}` мимо markdown-it проходит
+ * посимвольно.
+ */
+export declare function renderToStorage(markdown: string, urls: AttachmentUrls): string;

package/dist/markdown/render.js

@@ -0,0 +1,80 @@
+import MarkdownIt from 'markdown-it';
+// xhtmlOut: true — Confluence storage format = XHTML, void-элементы
+// (<hr/>, <br/>, <img/>) обязаны быть самозакрывающимися.
+// html: true — разрешить HTML (нужно для <!-- MACRO:... --> комментариев)
+const md = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: false,
+    breaks: false,
+    xhtmlOut: true,
+});
+export const PLACEHOLDER_RE = /\{\{(img|file):([^}]+)\}\}/g;
+export function extractPlaceholders(markdown) {
+    const images = new Set();
+    const files = new Set();
+    for (const m of markdown.matchAll(PLACEHOLDER_RE)) {
+        const name = m[2].trim();
+        if (m[1] === 'img')
+            images.add(name);
+        else
+            files.add(name);
+    }
+    return { images: [...images], files: [...files] };
+}
+function escapeXmlAttr(s) {
+    return s.replace(/[<>&"']/g, (c) => {
+        switch (c) {
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '&': return '&amp;';
+            case '"': return '&quot;';
+            case "'": return '&apos;';
+            default: return c;
+        }
+    });
+}
+export class MissingAttachmentUrlError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MissingAttachmentUrlError';
+    }
+}
+/**
+ * Превращает Markdown в Confluence storage format.
+ *
+ * Логика двушаговая:
+ *   1) markdown-it рендерит сам Markdown (без знания про плейсхолдеры).
+ *      `{{img:foo}}` и `{{file:foo}}` для markdown-it — обычный текст
+ *      без спецсимволов, доходят до выхода нетронутыми (могут быть
+ *      обёрнуты в <p>...</p>, что нас устраивает).
+ *   2) В готовом HTML регуляркой подставляем `<img src=URL/>` и
+ *      `<a href=URL>filename</a>` на места плейсхолдеров. URL обязан
+ *      существовать для каждого плейсхолдера — иначе
+ *      MissingAttachmentUrlError.
+ *
+ * Раньше использовалась схема через sentinel-токены (` CFLIMG_0 `):
+ * markdown-it трогал окружающие пробелы при упаковке в <p>, sentinel
+ * терял пробелы, итоговый .split() не находил совпадения и в Confluence
+ * вместо картинки попадал кусок «CFLIMG_0». Прямая регекс-замена по
+ * HTML этой проблемы лишена — `{{img:foo}}` мимо markdown-it проходит
+ * посимвольно.
+ */
+export function renderToStorage(markdown, urls) {
+    const html = md.render(markdown);
+    return html.replace(PLACEHOLDER_RE, (_full, kind, rawName) => {
+        const name = String(rawName).trim();
+        if (kind === 'img') {
+            const url = urls.images.get(name);
+            if (!url) {
+                throw new MissingAttachmentUrlError(`No uploaded URL for image '${name}' — was it included in publishPage().images and successfully uploaded?`);
+            }
+            return `<img src="${escapeXmlAttr(url)}" alt="${escapeXmlAttr(name)}" />`;
+        }
+        const url = urls.files.get(name);
+        if (!url) {
+            throw new MissingAttachmentUrlError(`No uploaded URL for file '${name}' — was it included in publishPage().files and successfully uploaded?`);
+        }
+        return `<a href="${escapeXmlAttr(url)}">${escapeXmlAttr(name)}</a>`;
+    });
+}

package/dist/markdown/validate.d.ts

@@ -0,0 +1,11 @@
+export declare class MarkdownValidationError extends Error {
+    constructor(message: string);
+}
+export interface ValidateOptions {
+    markdown: string;
+    imagePaths: string[];
+    filePaths: string[];
+    tableNames?: string[];
+    sourceLabel?: string;
+}
+export declare function validateMarkdown(opts: ValidateOptions): void;

package/dist/markdown/validate.js

@@ -0,0 +1,60 @@
+import { basename } from 'node:path';
+import { extractPlaceholders } from './render.js';
+export class MarkdownValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MarkdownValidationError';
+    }
+}
+export function validateMarkdown(opts) {
+    const { images, files } = extractPlaceholders(opts.markdown);
+    const tables = extractTablePlaceholders(opts.markdown);
+    const providedImages = new Set(opts.imagePaths.map((p) => basename(p)));
+    const providedFiles = new Set(opts.filePaths.map((p) => basename(p)));
+    const providedTables = new Set(opts.tableNames ?? []);
+    const label = opts.sourceLabel ? `${opts.sourceLabel}: ` : '';
+    const errors = [];
+    for (const name of images) {
+        if (!providedImages.has(name)) {
+            errors.push(`${label}image placeholder {{img:${name}}} has no matching file in images[]`);
+        }
+    }
+    for (const name of files) {
+        if (!providedFiles.has(name)) {
+            errors.push(`${label}file placeholder {{file:${name}}} has no matching file in files[]`);
+        }
+    }
+    for (const name of tables) {
+        if (!providedTables.has(name)) {
+            errors.push(`${label}table placeholder {{table:${name}}} has no matching table in tables[]`);
+        }
+    }
+    const referencedImages = new Set(images);
+    const referencedFiles = new Set(files);
+    const referencedTables = new Set(tables);
+    for (const name of providedImages) {
+        if (!referencedImages.has(name)) {
+            console.warn(`[validate] ${label}image '${name}' provided but not referenced by any {{img:...}} placeholder`);
+        }
+    }
+    for (const name of providedFiles) {
+        if (!referencedFiles.has(name)) {
+            console.warn(`[validate] ${label}file '${name}' provided but not referenced by any {{file:...}} placeholder`);
+        }
+    }
+    for (const name of providedTables) {
+        if (!referencedTables.has(name)) {
+            console.warn(`[validate] ${label}table '${name}' provided but not referenced by any {{table:...}} placeholder`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new MarkdownValidationError(`Markdown validation failed:\n  - ${errors.join('\n  - ')}`);
+    }
+}
+function extractTablePlaceholders(markdown) {
+    const tables = new Set();
+    for (const m of markdown.matchAll(/\{\{table:([a-z0-9_-]+)\}\}/gi)) {
+        tables.add(m[1].trim());
+    }
+    return [...tables];
+}

package/dist/pages/page.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Объектная модель для работы со страницами и таблицами Confluence.
+ */
+import type { ConfluenceClient, ConfluenceLabel, ConfluencePage } from '../client/client.js';
+import { Attachment } from '../attachments/attachment.js';
+import { Markdown } from '../markdown/markdown.js';
+/**
+ * Представляет страницу Confluence.
+ */
+export declare class Page {
+    readonly id: string;
+    readonly title: string;
+    private readonly storage;
+    private readonly client;
+    constructor(id: string, title: string, storage: string, client: ConfluenceClient);
+    /** Сырой storage-контент страницы. */
+    getStorage(): string;
+    /**
+     * Скачивает аттач страницы по имени файла. Возвращает сырые байты.
+     * Текстовая декодировка — через {@link getAttachmentText}.
+     */
+    getAttachment(filename: string): Promise<Buffer>;
+    /** Скачивает аттач и декодирует как текст (по умолчанию utf-8). */
+    getAttachmentText(filename: string, encoding?: BufferEncoding): Promise<string>;
+    /** Список аттачей страницы с историей версий (versions заполнены). */
+    getAttachments(): Promise<Attachment[]>;
+    /**
+     * Удаляет у всех аттачей страницы старые версии, оставляя только последнюю
+     * (max по номеру). Полезно для регулярно перезаписываемых файлов (CSV),
+     * которые иначе копят десятки версий. Возвращает число удалённых версий.
+     */
+    removeOldAttachmentVersions(): Promise<number>;
+    /** Лейблы страницы. */
+    getLabels(): Promise<ConfluenceLabel[]>;
+    /** Добавляет лейблы (идемпотентно). */
+    addLabels(labels: string[]): Promise<void>;
+    /** Дочерние страницы. */
+    getChildren(): Promise<ConfluencePage[]>;
+    /**
+     * Извлекает таблицу со страницы.
+     *
+     * @param target порядковый номер таблицы (0 = первая) или имя
+     *   table-excerpt-макроса, обёрнутого вокруг таблицы (параметр `name`).
+     * @throws если таблица не найдена
+     */
+    getTable(target?: number | string): Table;
+    /**
+     * Извлекает все таблицы со страницы.
+     */
+    getTables(): Table[];
+}
+/**
+ * Представляет таблицу Confluence (извлечённую из HTML storage format).
+ *
+ * Предоставляет методы для преобразования таблицы в разные форматы:
+ * - `toCells()` — массив строк и ячеек
+ * - `toAny()` — массив объектов с заголовками как ключи
+ * - `toType<T>()` — массив типизированных объектов с маппером
+ */
+export declare class Table {
+    private readonly cells;
+    private readonly headers;
+    constructor(tableHtml: string[][]);
+    /**
+     * Возвращает сырой массив ячеек таблицы.
+     */
+    toCells(): string[][];
+    /**
+     * Возвращает строки таблицы (без заголовков) как массив объектов.
+     *
+     * Ключи объектов — заголовки колонок.
+     * Если есть дублирующиеся заголовки, к имени добавляется порядковый номер.
+     *
+     * @example
+     *   table.toAny() → [
+     *     { 'Таб.№': '14800145', 'ФИО': 'Иванов И.И.', ... },
+     *     { 'Таб.№': '14800146', 'ФИО': 'Петров П.П.', ... },
+     *   ]
+     */
+    toAny(): Record<string, string>[];
+    /**
+     * Преобразует таблицу в массив типизированных объектов.
+     *
+     * @param mapper функция, которая заполняет поля результирующего объекта на основе строки таблицы
+     * @returns массив объектов типа T, заполненный маппером
+     *
+     * @example
+     *   const employees = table.toType<Employee>((row, emp) => {
+     *     emp.tabNumber = row['Таб.№'];
+     *     emp.fio = row['ФИО'];
+     *   });
+     */
+    toType<T>(mapper: (row: Record<string, string>, result: T) => void): T[];
+    /** Возвращает количество строк (включая заголовок). */
+    get rowCount(): number;
+    /** Возвращает количество колонок. */
+    get columnCount(): number;
+    /** Возвращает заголовки колонок. */
+    getHeaders(): string[];
+    /** Возвращает таблицу в Markdown формате для использования с макросами. */
+    toMarkdown(): Markdown;
+    /** Строит карту заголовков с обработкой дубликатов. */
+    private buildHeaderMap;
+}