@nxgt/material-vue 0.20.0 → 0.22.0

package/dist/lib/pdf-core/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The document model and its react-pdf renderer, shared by
+ * `@nxgt/material/print` and `@nxgt/material-vue/pdf`.
+ *
+ * `model/` is plain data and imports nothing from React. `render/` imports
+ * `react` and `@react-pdf/renderer` — optional peers in both libraries — so
+ * it is reached from the print (React) and pdf (Vue) entries only, never from
+ * a barrel: `scripts/verify-ssr-safe.ts` fails the build otherwise.
+ */
+export * from './model';
+export * from './render';

package/dist/lib/pdf-core/model/builders.d.ts

@@ -0,0 +1,54 @@
+import { PdfDocument, PdfInline, PdfNode, PdfPage, PrintValue } from './types';
+type NodeOf<T extends PdfNode['type']> = Extract<PdfNode, {
+    type: T;
+}>;
+type Options<T extends PdfNode['type'], K extends string = never> = Omit<NodeOf<T>, 'type' | K>;
+export declare const text: (content: string | PdfInline[], options?: Omit<Options<"text">, "content">) => NodeOf<"text">;
+export declare const heading: (text: string, level?: 1 | 2 | 3) => NodeOf<"heading">;
+export declare const stack: (children: PdfNode[], options?: Omit<Options<"stack">, "children">) => NodeOf<"stack">;
+export declare const row: (children: PdfNode[], options?: Omit<Options<"row">, "children">) => NodeOf<"row">;
+export declare const section: (title: string, children: PdfNode[]) => NodeOf<"section">;
+export declare const image: (src: string, options?: Omit<Options<"image">, "src">) => NodeOf<"image">;
+export declare const link: (href: string, text: string) => NodeOf<"link">;
+export declare const spacer: (size: number) => NodeOf<"spacer">;
+export declare const divider: () => NodeOf<"divider">;
+export declare const pageBreak: () => NodeOf<"pageBreak">;
+export declare const table: (options: Options<"table">) => NodeOf<"table">;
+export declare const keyValue: (items: {
+    label: string;
+    value: PrintValue;
+}[], options?: Omit<Options<"keyValue">, "items">) => NodeOf<"keyValue">;
+export declare const totals: (rows: NodeOf<"totals">["rows"]) => NodeOf<"totals">;
+export declare const metric: (options: Options<"metric">) => NodeOf<"metric">;
+export declare const badge: (text: string, color?: string) => NodeOf<"badge">;
+export declare const header: (options: Options<"header">) => NodeOf<"header">;
+export declare const pageNumber: (options?: Options<"pageNumber">) => NodeOf<"pageNumber">;
+export declare const page: (options: PdfPage) => PdfPage;
+/** A whole document; `version` is stamped for you. */
+export declare const pdfDocument: (options: Omit<PdfDocument, "version">) => PdfDocument;
+/**
+ * What `definePdfDocument` accepts: a function from your data (and more
+ * parameters, if you like) to a document without its `version`. A method
+ * signature, so that its parameters are checked both ways: an annotated
+ * `(inv: Invoice)` fits, while an unannotated first parameter is typed
+ * `unknown` (use it only after narrowing) and a later one with a default
+ * (`language = 'en'`) takes its type from the default.
+ */
+type PdfTemplate = {
+    build(data: unknown, ...rest: never[]): Omit<PdfDocument, 'version'>;
+}['build'];
+/**
+ * Types a template: a function from your data to a document. It returns the
+ * function unchanged, stamping `version` on what it builds. Annotate the
+ * data parameter; the others may have defaults (`language = 'en'`). Left
+ * unannotated, the data is `unknown`, so reading a property of it fails to
+ * compile in the template rather than where the template is called.
+ *
+ * @example
+ * const invoicePdf = definePdfDocument((inv: Invoice, language = 'en') => ({
+ *   language,
+ *   pages: [page({ pageNumbers: true, body: [heading(inv.number)] })],
+ * }));
+ */
+export declare function definePdfDocument<F extends PdfTemplate>(build: F): (...args: Parameters<F>) => PdfDocument;
+export {};

package/dist/lib/pdf-core/model/data-table.d.ts

@@ -0,0 +1,24 @@
+import { PrintColumn, PrintTableOptions } from '../../lib/print-table.utils';
+import { PdfNode } from './types';
+type TableNode = Extract<PdfNode, {
+    type: 'table';
+}>;
+type KeyValueNode = Extract<PdfNode, {
+    type: 'keyValue';
+}>;
+export type DataTableOptions = PrintTableOptions & Pick<TableNode, 'striped' | 'repeatHeader' | 'keepRowsWhole' | 'emptyText' | 'hideWhenEmpty'>;
+/**
+ * A `table` node from column definitions and plain rows — the model twin of
+ * `PrintDataTable`. Without `totalLabel`, the totals row reads "Total" in the
+ * document's language.
+ *
+ * @example
+ * dataTable(definePrintColumns<Line>([
+ *   { key: 'item', label: 'Item', flex: 3 },
+ *   { key: 'amount', label: 'Amount', format: 'amount', total: 'sum' },
+ * ]), invoice.lines, { currency: 'EUR' })
+ */
+export declare function dataTable<T>(columns: PrintColumn<T>[], rows: T[], options?: DataTableOptions): TableNode;
+/** A `keyValue` node from one row, read through column definitions. */
+export declare function keyValueOf<T>(fields: PrintColumn<T>[], data: T, options?: Pick<PrintTableOptions, 'currency'> & Pick<KeyValueNode, 'columns' | 'keepEmpty'>): KeyValueNode;
+export {};

package/dist/lib/pdf-core/model/index.d.ts

@@ -0,0 +1,4 @@
+export * from './builders';
+export * from './data-table';
+export * from './theme';
+export * from './types';

package/dist/lib/pdf-core/model/nodes.d.ts

@@ -0,0 +1,133 @@
+import { PdfAlign, PdfColor, PdfJsonValue, PdfStyle, PrintValue } from './types';
+export type PdfInline = string | {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    color?: PdfColor;
+    href?: string;
+};
+export type PdfTableColumn = {
+    label: string;
+    align?: PdfAlign;
+    /** Points, or a percentage of the table (`'25%'`); otherwise it flexes. */
+    width?: number | `${number}%`;
+    /** Share of the remaining width; 1 by default. */
+    flex?: number;
+};
+export type PdfNode = {
+    type: 'stack';
+    children: PdfNode[];
+    gap?: number;
+    style?: PdfStyle;
+} | {
+    type: 'row';
+    children: PdfNode[];
+    gap?: number;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between';
+    style?: PdfStyle;
+} | {
+    type: 'text';
+    content: string | PdfInline[];
+    variant?: 'body' | 'muted' | 'caption' | 'label';
+    style?: PdfStyle;
+} | {
+    type: 'heading';
+    text: string;
+    level?: 1 | 2 | 3;
+} | {
+    type: 'section';
+    title: string;
+    children: PdfNode[];
+} | {
+    type: 'image';
+    /** A URL or a data URL; PNG or JPEG. */
+    src: string;
+    width?: number;
+    height?: number;
+    fit?: 'contain' | 'cover';
+} | {
+    type: 'link';
+    href: string;
+    text: string;
+} | {
+    type: 'spacer';
+    size: number;
+} | {
+    type: 'divider';
+} | {
+    type: 'pageBreak';
+} | {
+    type: 'table';
+    columns: PdfTableColumn[];
+    rows: PrintValue[][];
+    /** Rows after the body, such as totals; kept together. */
+    footer?: PrintValue[][];
+    /** An empty first cell of a footer row reads "Total", translated. */
+    labelTotals?: boolean;
+    /** Zebra rows; `true` by default. */
+    striped?: boolean;
+    /** The header again at the top of each page; `true` by default. */
+    repeatHeader?: boolean;
+    /** A row never splits across pages; `true` by default. */
+    keepRowsWhole?: boolean;
+    /** Shown in one muted row when there are no rows. */
+    emptyText?: string;
+    /** Render nothing, not even the header, when there are no rows. */
+    hideWhenEmpty?: boolean;
+} | {
+    type: 'keyValue';
+    items: {
+        label: string;
+        value: PrintValue;
+    }[];
+    /** 1 or 2 columns of pairs; 1 by default. */
+    columns?: 1 | 2;
+    /** Print a pair whose value is empty, as `'—'`. */
+    keepEmpty?: boolean;
+} | {
+    type: 'totals';
+    rows: {
+        label: string;
+        value: PrintValue;
+        emphasis?: boolean;
+    }[];
+} | {
+    type: 'metric';
+    label: string;
+    value: PrintValue;
+    hint?: string;
+    /** A change in percent, shown as `+4%` or `-2%`. */
+    delta?: number;
+} | {
+    type: 'badge';
+    text: string;
+    color?: PdfColor;
+} | {
+    type: 'header';
+    title: string;
+    subtitle?: string;
+    reference?: string;
+    /** Printed before `reference`; `'#'` by default. */
+    referencePrefix?: string;
+    /** A URL or a data URL, PNG or JPEG. */
+    logo?: string | {
+        src: string;
+        width?: number;
+        height?: number;
+    };
+    /** Shown in the logo box when there is no `logo`. */
+    logoText?: string;
+    /** A QR code already rendered as a PNG data URL. */
+    qrDataUrl?: string | null;
+} | {
+    type: 'pageNumber';
+    format?: 'page-of' | 'page';
+    align?: PdfAlign;
+} | {
+    type: 'custom';
+    /** The renderer's name in the `custom` option. */
+    name: string;
+    props?: Record<string, PdfJsonValue>;
+};
+export type PdfNodeType = PdfNode['type'];

package/dist/lib/pdf-core/model/theme.d.ts

@@ -0,0 +1,16 @@
+import { PdfColor, PdfThemeColor, PdfThemeOverrides } from './types';
+export type PdfTheme = {
+    colors: Record<PdfThemeColor, string>;
+    fonts: Record<'sans' | 'serif' | 'mono', string>;
+};
+/**
+ * The light screen theme, in colours react-pdf reads (it takes no oklch):
+ * `primary`, `secondary`, `muted`, `border` and `qrBg` are the screen's
+ * `--primary`, `--secondary`, `--muted-foreground`, `--border` and `--muted`.
+ * Fonts are PDF standard fonts, so nothing has to be registered.
+ */
+export declare const defaultPdfTheme: PdfTheme;
+/** The default theme with `overrides` applied. */
+export declare function resolvePdfTheme(overrides?: PdfThemeOverrides): PdfTheme;
+/** A theme colour name resolved to its value; any other colour as it is. */
+export declare function resolvePdfColor(color: PdfColor | undefined, theme: PdfTheme): string | undefined;

package/dist/lib/pdf-core/model/types.d.ts

@@ -0,0 +1,108 @@
+import { PrintValue } from '../../lib/print-value.utils';
+import { PdfNode } from './nodes';
+export type * from './nodes';
+export type { PrintValue };
+/** A theme colour name (`'primary'`, `'muted'`, …) or a CSS colour (`'#0b7a4b'`). */
+export type PdfColor = PdfThemeColor | (string & {});
+/** A JSON value: what a document may carry, so it survives `JSON.stringify`. */
+export type PdfJsonValue = string | number | boolean | null | PdfJsonValue[] | {
+    [key: string]: PdfJsonValue;
+};
+/** A JSON-safe subset of react-pdf's style: numbers are points. */
+export type PdfStyle = {
+    margin?: number;
+    marginTop?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    padding?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    width?: number | string;
+    height?: number | string;
+    flex?: number;
+    gap?: number;
+    /** One of the theme's fonts; `'sans'` by default. */
+    fontFamily?: 'sans' | 'serif' | 'mono';
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold';
+    fontStyle?: 'normal' | 'italic';
+    textAlign?: 'left' | 'center' | 'right' | 'justify';
+    color?: PdfColor;
+    backgroundColor?: PdfColor;
+    borderWidth?: number;
+    borderColor?: PdfColor;
+    borderRadius?: number;
+};
+/** Points on each side; `x` and `y` set both sides of an axis. */
+export type PdfBox = {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+    x?: number;
+    y?: number;
+};
+export type PdfPageSize = 'A3' | 'A4' | 'A5' | 'LETTER' | 'LEGAL' | [number, number];
+export type PdfAlign = 'left' | 'center' | 'right';
+/** `true` prints "Page 2 of 5" centred at the bottom of every page. */
+export type PdfPageNumbers = boolean | {
+    align?: PdfAlign;
+    format?: 'page-of' | 'page';
+};
+export type PdfWatermark = string | {
+    text: string;
+    /** 0 to 1; 0.08 by default. */
+    opacity?: number;
+    /** Degrees, counter-clockwise; 35 by default. */
+    angle?: number;
+    color?: PdfColor;
+    /** Points; 72 by default. */
+    fontSize?: number;
+};
+/** Document information, as PDF readers show it. */
+export type PdfMeta = {
+    title?: string;
+    author?: string;
+    subject?: string;
+    keywords?: string;
+    creator?: string;
+    producer?: string;
+};
+/** Colours and fonts; every field is optional and falls back to the default. */
+export type PdfThemeOverrides = {
+    colors?: Partial<Record<PdfThemeColor, string>>;
+    fonts?: Partial<Record<'sans' | 'serif' | 'mono', string>>;
+};
+export type PdfThemeColor = 'primary' | 'secondary' | 'text' | 'muted' | 'border' | 'headerBg' | 'headerText' | 'rowAlt' | 'logoBg' | 'qrBg' | 'success' | 'error';
+/** The page shell: size, margins and what repeats on every page. */
+export type PdfPageOptions = {
+    size?: PdfPageSize;
+    orientation?: 'portrait' | 'landscape';
+    /** Points; a number for every side. */
+    margins?: number | PdfBox;
+    /** Space kept at the bottom for the footer and page numbers; 24 by default. */
+    footerHeight?: number;
+    pageNumbers?: PdfPageNumbers;
+    watermark?: PdfWatermark;
+};
+export type PdfPage = PdfPageOptions & {
+    /** Repeated at the top of every page, in the flow. */
+    header?: PdfNode[];
+    /** Repeated at the bottom of every page. */
+    footer?: PdfNode[];
+    body: PdfNode[];
+};
+export type PdfDocument = {
+    version: 1;
+    meta?: PdfMeta;
+    /** Picks the built-in strings (`'en'`, `'fr'`) and the PDF's language. */
+    language?: string;
+    /** Formats amounts, dates and numbers; defaults to `language`. */
+    locale?: string;
+    timeZone?: string;
+    theme?: PdfThemeOverrides;
+    pages: PdfPage[];
+};

package/dist/lib/pdf-core/render/context.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from 'react';
+import { PrintValue, PrintValueOptions } from '../../lib/print-value.utils';
+import { PdfTheme } from '../model/theme';
+import { PdfNode, PdfThemeOverrides } from '../model/types';
+import { PdfStyles } from './styles';
+/** Translates a built-in string: its key, English fallback and values. */
+export type PdfTranslate = (key: string, fallback: string, values?: Record<string, string | number>) => string;
+/** Renders a `{ type: 'custom' }` node registered under its `name`. */
+export type PdfCustomRenderer = (props: Record<string, unknown>, context: PdfRenderContext) => ReactNode;
+/**
+ * Everything a node renderer needs, resolved once per document. It is plain
+ * data and functions — never a hook — because react-pdf calls the `render`
+ * callbacks of page numbers and fixed elements at layout time, outside React,
+ * where a hook throws.
+ */
+export type PdfRenderContext = {
+    language: string;
+    locale?: string;
+    timeZone?: string;
+    theme: PdfTheme;
+    styles: PdfStyles;
+    t: PdfTranslate;
+    /**
+     * Formats a value with the document's locale and time zone, as text the
+     * standard fonts can print ({@link toPdfText}).
+     */
+    format: (value: PrintValue, options?: Pick<PrintValueOptions, 'empty'>) => string;
+    /** Renders child nodes; set by `createPdfRenderContext`. */
+    renderNodes: (nodes: PdfNode[] | undefined) => ReactNode[];
+    custom: Record<string, PdfCustomRenderer>;
+};
+export type PdfRenderOptions = {
+    /** `'en'` or `'fr'` pick the built-in strings; `'en'` by default. */
+    language?: string;
+    /** Formats amounts and dates; defaults to `language`. */
+    locale?: string;
+    timeZone?: string;
+    theme?: PdfThemeOverrides;
+    /**
+     * Translates the built-in strings (`material.print.*` keys); without it,
+     * the English fallbacks are printed.
+     */
+    translate?: PdfTranslate;
+    /** Renderers for `{ type: 'custom', name }` nodes. */
+    custom?: Record<string, PdfCustomRenderer>;
+};
+export declare const DEFAULT_PDF_LANGUAGE = "en";
+/** Text with the characters the standard fonts lack replaced by ones they have. */
+export declare function toPdfText(text: string): string;
+export declare function createPdfRenderContext(options: PdfRenderOptions, renderNodes: (nodes: PdfNode[] | undefined, context: PdfRenderContext) => ReactNode[]): PdfRenderContext;

package/dist/lib/pdf-core/render/document.d.ts

@@ -0,0 +1,21 @@
+import { DocumentProps } from '@react-pdf/renderer';
+import { ReactElement, ReactNode } from 'react';
+import { PdfDocument, PdfMeta } from '../model/types';
+import { PdfRenderContext, PdfRenderOptions } from './context';
+/** A render context for a document, or for blocks outside of one. */
+export declare function createPdfContext(options?: PdfRenderOptions): PdfRenderContext;
+export type PdfDocumentShellOptions = PdfMeta & {
+    /** Written to the PDF as its language, such as `'fr'`. */
+    language?: string;
+};
+/** The react-pdf `Document`: metadata and the pages. */
+export declare function renderPdfDocumentShell(options: PdfDocumentShellOptions, pages: ReactNode[]): ReactElement<DocumentProps>;
+export type RenderPdfElementOptions = Pick<PdfRenderOptions, 'translate' | 'custom'> & {
+    /** `creator` and `producer` when the document's `meta` names none. */
+    defaultCreator?: string;
+};
+/**
+ * Turns a model document into the react-pdf element tree that `pdf()`,
+ * `renderToBuffer()` or `PDFViewer` take.
+ */
+export declare function renderPdfElement(doc: PdfDocument, options?: RenderPdfElementOptions): ReactElement<DocumentProps>;

package/dist/lib/pdf-core/render/index.d.ts

@@ -0,0 +1,5 @@
+export * from './context';
+export * from './document';
+export * from './page';
+export { renderPdfNode, renderPdfNodes } from './render-node';
+export * from './styles';

package/dist/lib/pdf-core/render/nodes/blocks.d.ts

@@ -0,0 +1,19 @@
+import { Text, View } from '@react-pdf/renderer';
+import { PdfNode } from '../../model/types';
+import { PdfRenderContext } from '../context';
+type NodeOf<T extends PdfNode['type']> = Extract<PdfNode, {
+    type: T;
+}>;
+/** Label and value pairs, in one or two columns; empty values are skipped. */
+export declare function renderKeyValue(node: NodeOf<'keyValue'>, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View> | null;
+/** A right-aligned box of totals; an `emphasis` row is the dark last row. */
+export declare function renderTotals(node: NodeOf<'totals'>, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+/** One figure with its label, an optional hint and change. */
+export declare function renderMetric(node: NodeOf<'metric'>, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare function renderBadge(node: NodeOf<'badge'>, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+/**
+ * "Page 2 of 5" (or "Page 2"), translated. react-pdf calls `render` at layout
+ * time, outside React, so it only uses what the context already resolved.
+ */
+export declare function renderPageNumber(node: NodeOf<'pageNumber'>, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').TextProps> | import('@react-pdf/renderer').SVGTextProps, Text>;
+export {};

package/dist/lib/pdf-core/render/nodes/header.d.ts

@@ -0,0 +1,14 @@
+import { View } from '@react-pdf/renderer';
+import { PdfNode } from '../../model/types';
+import { PdfRenderContext } from '../context';
+type HeaderNode = Extract<PdfNode, {
+    type: 'header';
+}>;
+/**
+ * The title block: logo (an image, or `logoText` in a box) on the left, the
+ * title, subtitle and reference centred, a QR code on the right. A side with
+ * nothing to show keeps an empty box of the other side's width, so the title
+ * stays centred; with neither, the title is centred on the page.
+ */
+export declare function renderHeader(node: HeaderNode, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export {};

package/dist/lib/pdf-core/render/nodes/layout.d.ts

@@ -0,0 +1,44 @@
+import { Image, Text, View } from '@react-pdf/renderer';
+import { PdfNode, PdfStyle } from '../../model/types';
+import { PdfRenderContext } from '../context';
+type NodeOf<T extends PdfNode['type']> = Extract<PdfNode, {
+    type: T;
+}>;
+/** A model style with its theme colours and font resolved. */
+export declare function toStyle(style: PdfStyle | undefined, ctx: PdfRenderContext): {
+    borderColor?: string | undefined;
+    backgroundColor?: string | undefined;
+    color?: string | undefined;
+    fontFamily?: string | undefined;
+    margin?: number;
+    marginTop?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    padding?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    width?: number | string;
+    height?: number | string;
+    flex?: number;
+    gap?: number;
+    fontSize?: number;
+    fontWeight?: "normal" | "bold";
+    fontStyle?: "normal" | "italic";
+    textAlign?: "left" | "center" | "right" | "justify";
+    borderWidth?: number;
+    borderRadius?: number;
+};
+export declare const renderStack: (node: NodeOf<"stack">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare const renderRow: (node: NodeOf<"row">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare const renderText: (node: NodeOf<"text">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').TextProps> | import('@react-pdf/renderer').SVGTextProps, Text>;
+export declare const renderHeading: (node: NodeOf<"heading">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').TextProps> | import('@react-pdf/renderer').SVGTextProps, Text>;
+export declare const renderSection: (node: NodeOf<"section">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare const renderImage: (node: NodeOf<"image">) => import('react').CElement<import('@react-pdf/renderer').ImageProps, Image>;
+export declare const renderLink: (node: NodeOf<"link">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').TextProps> | import('@react-pdf/renderer').SVGTextProps, Text>;
+export declare const renderSpacer: (node: NodeOf<"spacer">) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare const renderDivider: (_node: NodeOf<"divider">, ctx: PdfRenderContext) => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export declare const renderPageBreak: () => import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View>;
+export {};

package/dist/lib/pdf-core/render/nodes/table.d.ts

@@ -0,0 +1,14 @@
+import { View } from '@react-pdf/renderer';
+import { PdfNode } from '../../model/types';
+import { PdfRenderContext } from '../context';
+type TableNode = Extract<PdfNode, {
+    type: 'table';
+}>;
+/**
+ * A table: a header row that repeats at the top of each page the table
+ * crosses, body rows that never split (and stripe), then footer rows (totals)
+ * kept together. With no rows, the header and one muted row, or nothing with
+ * `hideWhenEmpty`.
+ */
+export declare function renderTable(node: TableNode, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').ViewProps>, View> | null;
+export {};

package/dist/lib/pdf-core/render/page.d.ts

@@ -0,0 +1,30 @@
+import { Page } from '@react-pdf/renderer';
+import { ReactNode } from 'react';
+import { PdfBox, PdfPageOptions } from '../model/types';
+import { PdfRenderContext } from './context';
+export declare const DEFAULT_PDF_MARGINS: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export declare const DEFAULT_FOOTER_HEIGHT = 24;
+export type PdfMargins = typeof DEFAULT_PDF_MARGINS;
+/**
+ * Margins in points from a number or a box: a side wins over its axis
+ * (`x`, `y`), which wins over the default.
+ */
+export declare function resolvePdfMargins(margins?: number | PdfBox): PdfMargins;
+export type PdfPageParts = {
+    /** Repeated at the top of every page, in the flow. */
+    header?: ReactNode;
+    /** Repeated at the bottom of every page, in the space kept for it. */
+    footer?: ReactNode;
+    body: ReactNode[];
+};
+/**
+ * One react-pdf `Page`: size, orientation and margins, the header fixed at
+ * the top of each page, the footer and page number fixed in the space kept
+ * at the bottom, and the watermark behind everything.
+ */
+export declare function renderPdfPage(options: PdfPageOptions, parts: PdfPageParts, ctx: PdfRenderContext): import('react').CElement<import('react').PropsWithChildren<import('@react-pdf/renderer').PageProps>, Page>;

package/dist/lib/pdf-core/render/render-node.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { PdfNode } from '../model/types';
+import { PdfRenderContext } from './context';
+/**
+ * Renders one model node as react-pdf elements. An unknown `type` throws: a
+ * document from a newer version, or a typo in hand-written JSON.
+ */
+export declare function renderPdfNode(node: PdfNode, context: PdfRenderContext): ReactNode;
+/** Renders a list of nodes, each under its index as key. */
+export declare function renderPdfNodes(nodes: PdfNode[] | undefined, context: PdfRenderContext): ReactNode[];