@openpresentation/opf 0.13.0 → 0.15.1

package/dist/validation-types-BOcY9GTs.d.ts

@@ -0,0 +1,276 @@
+import { a as Catalog } from './catalog-refs-BSfGELpt.js';
+import { T as TextMeasurement } from './composition-D2tghM82.js';
+import { c as FindingSeverity, F as FindingReport } from './finding-CT_f_vbD.js';
+import { J as JsonPrimitive } from './json-BFSdESOE.js';
+
+/**
+ * Template variables: typed, named values a deck declares once and uses in many
+ * places, and the one deterministic function that turns a deck (or a template,
+ * "an incomplete OPF file") plus values into a concrete deck.
+ *
+ * Pure: no clock, locale, time zone, network, file access or randomness. See
+ * docs/templates-and-variables.md for the syntax and the recorded decisions.
+ */
+declare const VARIABLE_KINDS: readonly ["color", "text", "number", "date", "image", "url", "list"];
+type VariableKind = (typeof VARIABLE_KINDS)[number];
+type VariableValues = Record<string, unknown>;
+/** Default display pattern of a date variable inserted inline. */
+declare const DEFAULT_VARIABLE_DATE_FORMAT = "MMMM d, yyyy";
+interface VariableDeclaration {
+    id: string;
+    kind: VariableKind;
+    /** JSON pointer of the declaration. */
+    path: string;
+    /** False only when the declaration sets `required: false`. */
+    required: boolean;
+    /** Declared (default or current) value, normalized to the kind. Undefined when unfilled. */
+    value?: unknown;
+    example?: unknown;
+    format?: string;
+    label?: string;
+    description?: string;
+}
+type VariableUseForm = "token" | "reference";
+interface VariableUse {
+    id: string;
+    /** JSON pointer of the string that carries the token or reference. */
+    path: string;
+    form: VariableUseForm;
+}
+type VariableDiagnosticCode = "variable-unfilled" | "variable-example-used" | "variable-invalid-value" | "variable-unknown" | "variable-unknown-value" | "variable-unknown-builtin" | "variable-builtin-missing" | "variable-unused" | "variable-rich-flattened" | "variable-format";
+type VariableDiagnosticSeverity = "error" | "warning" | "info";
+interface VariableDiagnostic {
+    code: VariableDiagnosticCode;
+    severity: VariableDiagnosticSeverity;
+    /** JSON pointer into the document (declaration or use). */
+    path: string;
+    /** The variable id the diagnostic is about. */
+    id: string;
+    message: string;
+}
+interface ResolveVariablesOptions {
+    /**
+     * Treat the document as a template (overrides the root `template` marker):
+     * unfilled required variables are informational and the output stays a
+     * template. Default: the root `template` marker.
+     */
+    template?: boolean;
+    /** Use each unfilled variable's `example` (previews of a template). Default false. */
+    examples?: boolean;
+    /**
+     * Allow unfilled required variables (a partial fill): they are informational,
+     * their tokens and references stay as written, and their declarations remain
+     * in the output so a later pass can fill them. Default false.
+     */
+    partial?: boolean;
+    /** Throw OPFVariableError when any diagnostic has severity "error". Default false. */
+    strict?: boolean;
+}
+interface ResolveVariablesResult {
+    /**
+     * The concrete deck. Content variables are substituted and their declarations
+     * removed; color variables keep their `var:<id>` references and carry the
+     * resolved values; `template` is removed once nothing is unfilled. Unchanged
+     * parts of the input are shared, never mutated: treat the result as immutable.
+     */
+    presentation: Record<string, unknown>;
+    diagnostics: VariableDiagnostic[];
+    /** Ids of required variables that still have no value, in declaration order. */
+    unfilled: string[];
+    /** Ids whose `example` was used because the variable was unfilled. */
+    examplesUsed: string[];
+    /** True when no required variable is unfilled. */
+    complete: boolean;
+}
+declare class OPFVariableError extends Error {
+    readonly diagnostics: VariableDiagnostic[];
+    constructor(diagnostics: VariableDiagnostic[]);
+}
+/** True when the root `template` marker is set. */
+declare function isTemplate(presentation: unknown): boolean;
+/** Coerce a raw value (from a values file, a form or a declaration) to the kind's canonical value. */
+declare function coerceVariableValue(kind: VariableKind, raw: unknown): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    message: string;
+};
+/** The declarations of the document's `variables` map, in declaration order. Entries the schema rejects are skipped. */
+declare function variableDeclarations(presentation: unknown): VariableDeclaration[];
+/**
+ * True when the document declares a non-color variable, is marked as a template, or uses a built-in variable
+ * (`{{speaker.name}}`, `var:organization.logo`): the cases where resolveVariables changes the document.
+ */
+declare function hasContentVariables(presentation: unknown): boolean;
+/** Format a number with a display pattern (see the schema `NumberVariable.format`). */
+declare function formatVariableNumber(value: number, pattern?: string): {
+    text: string;
+} | {
+    error: string;
+};
+/**
+ * Resolve a presentation's variables against caller-supplied values and return
+ * the concrete deck. Pure and deterministic; never invents content: a value
+ * comes from the caller, the declaration's `value`, or (only when
+ * `options.examples` is set) the declaration's `example`. See
+ * docs/templates-and-variables.md.
+ */
+declare function resolveVariables(presentation: unknown, values?: VariableValues, options?: ResolveVariablesOptions): ResolveVariablesResult;
+interface VariableInfo extends VariableDeclaration {
+    /** True when the declaration (or the supplied values) gives the variable a value. */
+    filled: boolean;
+    /** Every place the variable is referenced. */
+    uses: VariableUse[];
+}
+/**
+ * The variables a deck or template declares, for fill forms and agents: kind,
+ * label, requirement, example, current value and every place each is used.
+ */
+declare function listVariables(presentation: unknown, values?: VariableValues): VariableInfo[];
+interface BuiltinVariableInfo {
+    /** The dotted name, as written inside `{{...}}` or after `var:`. */
+    name: string;
+    kind: VariableKind;
+    /** Short label for pickers, such as "Speaker name". */
+    label: string;
+    /** The value the document gives it, when it has one (a string, an Asset or the list of names). */
+    value?: unknown;
+    /** True when the document has a source value for it. Unavailable built-ins resolve to nothing. */
+    available: boolean;
+    /** Every place the document uses it. */
+    uses: VariableUse[];
+}
+/**
+ * The built-in variables of a deck, for pickers and agents: the generic names (`deck.*`, `speaker.*`, `speakers`,
+ * `organization.*`) first, then the id-addressed ones (`speaker.<id>.*`, `organization.<id>.*`) of each speaker and
+ * organization that has an id. Each carries its kind, current source value and where the document uses it.
+ */
+declare function listBuiltinVariables(presentation: unknown): BuiltinVariableInfo[];
+
+/**
+ * The six questions core's `validate` asks. `format`, `references` and `policy` can produce errors by default;
+ * `accessibility`, `layout` and `content` report warnings and info unless a host promotes them.
+ */
+type ValidationCategory = 'format' | 'references' | 'policy' | 'accessibility' | 'layout' | 'content';
+/** Every category, in report order. */
+declare const validationCategories: readonly ValidationCategory[];
+/**
+ * What a rule needs, which decides what it costs: `syntax` reads the JSON text, `structure` reads the document
+ * alone, `composition` builds slide compositions (text fitting and geometry), the expensive part.
+ */
+type ValidationRuleCost = 'syntax' | 'structure' | 'composition';
+interface ValidationRuleInfo {
+    /** Stable `opf/<name>` id. */
+    id: string;
+    name: string;
+    category: ValidationCategory;
+    /** Default severity. Some findings of a rule differ from it and say so: see the rule's description. */
+    severity: FindingSeverity;
+    cost: ValidationRuleCost;
+    summary: string;
+    /** Why the rule exists. */
+    rationale: string;
+    /** The accessibility, format or print-preflight standard it follows, when there is one. */
+    standard?: string;
+    /** What the check cannot see or approximates. */
+    approximations?: string;
+    /** Threshold names (`ValidationThresholds`) the rule reads. */
+    thresholds?: (keyof ValidationThresholds)[];
+}
+interface ValidationThresholds {
+    /** Minimum WCAG contrast ratio for normal text. WCAG 2.x AA: 4.5. */
+    contrastNormal: number;
+    /** Minimum ratio for large text (at least 18 pt, or 14 pt bold). WCAG 2.x AA: 3. */
+    contrastLarge: number;
+    /** Smallest rendered text size, in points, before `opf/min-font-size` reports. */
+    minFontSizePt: number;
+    /** Minimum effective pixels per inch of an embedded raster image at its displayed size. */
+    minImagePpi: number;
+    /** Smallest CIE76 colour difference between two chart series (after colour-vision simulation) before they count as confusable. */
+    minSeriesColorDifference: number;
+}
+/** Explicit host policy: the values a field may take. Document metadata is never interpreted as policy. */
+interface Contract {
+    /** JSON Pointer pattern; a complete '*' segment matches one path segment. */
+    path: string;
+    allowedValues: JsonPrimitive[];
+    /** Default `error`. */
+    severity?: FindingSeverity;
+    message?: string;
+    documentation?: string;
+}
+/**
+ * What the layout rules read from a fonts handle (the object `loadFonts()` of the renderer returns): the host's
+ * measured text widths. Without one, composition uses core's portable estimate. A function receives the zero-based
+ * slide index, so a host can supply a script-aware measurement per slide.
+ */
+interface ValidateFonts {
+    textMeasurement?: TextMeasurement | ((slideIndex: number) => TextMeasurement | undefined);
+}
+interface ValidateOptions {
+    /**
+     * Run only these rules or categories: full ids (`opf/text-contrast`), bare names (`text-contrast`) or category
+     * names (`format`). `only: ['format']` costs what the schema check costs and builds no layout.
+     */
+    only?: readonly string[];
+    /** Rules or categories not to run (same names). */
+    ignore?: readonly string[];
+    /** Severity per rule or category, or `off`. A rule beats its category. Promotes or demotes; it never skips the check's cost. */
+    severity?: Record<string, FindingSeverity | 'off'>;
+    /**
+     * Suppress a rule (or `*`, or a category) below a JSON Pointer prefix, for one accepted exception, for example
+     * `{ rule: 'opf/text-contrast', path: '/slides/3' }`. A prefix matches whole path segments.
+     */
+    ignorePaths?: readonly {
+        rule: string;
+        path: string;
+    }[];
+    /** Catalogs the host registered, matched by source; the first is the host default for an omitted catalogs.default. Nothing is fetched. */
+    catalogs?: readonly Catalog[];
+    /** Host policy (category `policy`). */
+    contracts?: readonly Contract[];
+    thresholds?: Partial<ValidationThresholds>;
+    /** The host's fonts. The layout rules use `fonts.textMeasurement`; see `ValidateFonts`. */
+    fonts?: ValidateFonts;
+    /** Chart series palette (opaque `#RRGGBB`), in the engine's order. Default: the palette opf-render and opf-pptx use. */
+    chartPalette?: readonly string[];
+    /** Check as a template (true) or a normal deck (false), overriding the root `template` marker. */
+    template?: boolean;
+    /** Values to fill variables with before checking, keyed by variable id. */
+    values?: VariableValues;
+}
+interface ValidationChecks {
+    /** `checked` for text input (JSON syntax and duplicate keys), `not-applicable` for a parsed document. */
+    syntax: 'checked' | 'not-applicable';
+    schema: 'checked' | 'not-run';
+    /** Content references, assets, datasets and citations, resolved against the document's catalogs groups and the registered catalogs. Nothing is fetched. */
+    references: 'checked' | 'not-run';
+    policy: 'checked' | 'not-run';
+    accessibility: 'checked' | 'not-run';
+    content: 'checked' | 'not-run';
+    /**
+     * `not-run` when no layout rule ran, `estimated` when text widths are core's portable estimate, `measured` when the host
+     * passed `fonts.textMeasurement`.
+     */
+    layout: 'not-run' | 'estimated' | 'measured';
+    /** Text contrast is computed against solid, gradient and pattern backgrounds; picture pixels are never read. */
+    backgroundPixels: 'not-read';
+    /** Image resolution reads only embedded `data:` images; URLs are never fetched. */
+    imageBytes: 'embedded-only';
+    nativeExport: 'not-checked';
+}
+interface ValidationReport extends FindingReport {
+    /**
+     * Whether the document passes the schema and the semantic format checks. `null` when the text was not JSON, so no
+     * schema check could run. A required variable with no value does not make a document schema-invalid.
+     */
+    schemaValid: boolean | null;
+    checks: ValidationChecks;
+    /** Documents that declare content variables or are templates: whether they were checked as a template. */
+    template?: boolean;
+    /** Documents that declare content variables or are templates: the required variables that have no value. */
+    unfilledVariables?: string[];
+}
+
+export { variableDeclarations as A, type BuiltinVariableInfo as B, type Contract as C, DEFAULT_VARIABLE_DATE_FORMAT as D, OPFVariableError as O, type ResolveVariablesOptions as R, type ValidateOptions as V, type ValidationReport as a, type ResolveVariablesResult as b, VARIABLE_KINDS as c, type ValidateFonts as d, type ValidationCategory as e, type ValidationChecks as f, type ValidationRuleCost as g, type ValidationRuleInfo as h, type ValidationThresholds as i, type VariableDeclaration as j, type VariableDiagnostic as k, type VariableDiagnosticCode as l, type VariableDiagnosticSeverity as m, type VariableInfo as n, type VariableKind as o, type VariableUse as p, type VariableUseForm as q, type VariableValues as r, coerceVariableValue as s, formatVariableNumber as t, hasContentVariables as u, isTemplate as v, listBuiltinVariables as w, listVariables as x, resolveVariables as y, validationCategories as z };

package/dist/validator.d.ts

@@ -1,4 +1,63 @@
-import './catalogs-ywCamd8C.js';
-import './schemas-BbPonsTz.js';
-import './presentation-mG-IYErQ.js';
-export { O as OPFValidationError, S as SchemaOrKind, d as ValidateOptions, V as ValidationIssue, e as ValidationResult, o as assertValid, p as assertValidCatalogRecord, q as assertValidPresentation, B as promotedRegionKeys, x as validate, y as validateCatalogRecord, z as validatePresentation } from './validator-CIylxoIm.js';
+import { a as CatalogRecordKind } from './catalog-schemas-CinPh5WA.js';
+import { a as Finding } from './finding-CT_f_vbD.js';
+import { P as Presentation } from './presentation-CDKQVkyI.js';
+import { i as ValidationThresholds, h as ValidationRuleInfo, a as ValidationReport, V as ValidateOptions } from './validation-types-BOcY9GTs.js';
+export { C as Contract, d as ValidateFonts, e as ValidationCategory, f as ValidationChecks, g as ValidationRuleCost, z as validationCategories } from './validation-types-BOcY9GTs.js';
+import './catalog-refs-BSfGELpt.js';
+import './schemas.js';
+import './json-BFSdESOE.js';
+import './composition-D2tghM82.js';
+import './chart-data-BnNqgnC-.js';
+
+/**
+ * The series palette opf-render and opf-pptx draw charts with (`CHART_COLORS`), in series order. A host with
+ * its own palette passes `ValidateOptions.chartPalette`.
+ */
+declare const DEFAULT_CHART_PALETTE: readonly string[];
+
+/**
+ * The rule registry: every rule `validate` can report, with its category, default severity, cost, rationale and the
+ * standard it follows. The format, references and policy rules are produced by the schema and reference checks; the
+ * accessibility, layout and content rules are implemented in `rules-*.ts`. Each rule has a stable `opf/<name>` id.
+ */
+declare const DEFAULT_VALIDATION_THRESHOLDS: Readonly<ValidationThresholds>;
+/**
+ * Every rule `validate` can report, with its category, default severity, cost, rationale and approximations, ordered by
+ * category (format, references, policy, accessibility, layout, content) and, within one, in report order.
+ */
+declare const validationRules: readonly ValidationRuleInfo[];
+/** The rule a full id (`opf/text-contrast`) or bare name (`text-contrast`) names, or undefined. */
+declare function findValidationRule(name: string): ValidationRuleInfo | undefined;
+
+declare const promotedRegionKeys: readonly ["left", "center", "right", "left+center", "center+right", "left+center+right", "top", "middle", "bottom", "top+middle", "middle+bottom", "top+middle+bottom", "top:left", "top:center", "top:right", "top:left+center", "top:center+right", "top:left+center+right", "middle:left", "middle:center", "middle:right", "middle:left+center", "middle:center+right", "middle:left+center+right", "bottom:left", "bottom:center", "bottom:right", "bottom:left+center", "bottom:center+right", "bottom:left+center+right", "top+middle:left", "top+middle:center", "top+middle:right", "top+middle:left+center", "top+middle:center+right", "top+middle:left+center+right", "middle+bottom:left", "middle+bottom:center", "middle+bottom:right", "middle+bottom:left+center", "middle+bottom:center+right", "middle+bottom:left+center+right", "top+middle+bottom:left", "top+middle+bottom:center", "top+middle+bottom:right", "top+middle+bottom:left+center", "top+middle+bottom:center+right", "top+middle+bottom:left+center+right"];
+
+declare class OPFValidationError extends Error {
+    /** The full report that failed. */
+    readonly report: ValidationReport;
+    /** The error-severity findings of the report. */
+    readonly findings: Finding[];
+    constructor(report: ValidationReport);
+}
+/**
+ * Check a presentation. `input` is a parsed presentation (an object) or the text of one, which is read as strict JSON and nothing
+ * else: syntax errors and duplicate keys come back with line and column, and findings carry the range of the value they are
+ * about. YAML and Markdown go through `fromYaml` and `fromMarkdown`, which call this for you.
+ *
+ * Never throws for a bad document, only for bad options (a `TypeError` naming the unknown rule, threshold or option, so a
+ * typo cannot silently disable a check).
+ */
+declare function validate(input: unknown, options?: ValidateOptions): ValidationReport;
+/**
+ * Throw `OPFValidationError` (carrying the `report`) unless `validate(value, options)` is valid; afterwards TypeScript
+ * knows `value` is a `Presentation`. It takes a parsed value, not text. Pass `{ only: ['format'] }` for the cheap check.
+ */
+declare function assertValid(value: unknown, options?: ValidateOptions): asserts value is Presentation;
+/**
+ * Check one published catalog record file (an audience, theme, layout, font scheme, chart type and so on) against its
+ * companion schema, `$schema` and `id` included. The report has the same shape as `validate`'s; every finding is `format`.
+ * A record a document embeds is checked by `validate`, keyed by its id and without `$schema`.
+ */
+declare function validateCatalogRecord(kind: CatalogRecordKind, value: unknown): ValidationReport;
+declare function assertValidCatalogRecord(kind: CatalogRecordKind, value: unknown): void;
+
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, ValidateOptions, ValidationReport, ValidationRuleInfo, ValidationThresholds, assertValid, assertValidCatalogRecord, findValidationRule, promotedRegionKeys, validate, validateCatalogRecord, validationRules };

package/dist/validator.js

@@ -1,5 +1,5 @@
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation } from './chunk-IYCJUKWD.js';
-export { promotedRegionKeys } from './chunk-MPM7NRG7.js';
-import './chunk-S5W34SIJ.js';
-import './chunk-E34DJ5LL.js';
-import './chunk-7QBCWNWL.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-QDI75P2M.js';
+export { promotedRegionKeys } from './chunk-O744SXXA.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-2CJPC4HI.js';

package/dist/yaml.d.ts

@@ -0,0 +1,102 @@
+import { a as Catalog } from './catalog-refs-BSfGELpt.js';
+import { P as Presentation } from './presentation-CDKQVkyI.js';
+import { V as ValidateOptions, a as ValidationReport } from './validation-types-BOcY9GTs.js';
+import { a as Finding, b as FindingLocation } from './finding-CT_f_vbD.js';
+import './composition-D2tghM82.js';
+import './chart-data-BnNqgnC-.js';
+import './json-BFSdESOE.js';
+
+/** A finding located in the YAML source: `yaml/<rule>` syntax and dialect errors (category `format`) and the OPF findings of the parsed deck. */
+type YamlFinding = Finding & {
+    location: FindingLocation;
+};
+interface YamlComments {
+    /** How many comments the text holds, not counting the `# yaml-language-server:` modeline. */
+    count: number;
+    /** The `# yaml-language-server: $schema=...` first-line modeline, when there is one. */
+    modeline?: string;
+}
+/** Find the comments of a YAML text (they are lost when a command rewrites the file) and its editor modeline. */
+declare function scanYamlComments(source: string): YamlComments;
+
+/**
+ * OPF as YAML (RR-56): read a deck written as YAML and write any valid deck as YAML, with no renderer, fonts, network
+ * or model. JSON stays the canonical form; `.opf.yaml` is an authoring serialization of the same data.
+ *
+ * The reader accepts one dialect, strict by default: JSON-compatible YAML 1.2 (core schema) with exactly one document
+ * whose root is a mapping, no duplicate keys, no custom tags, no anchors, aliases or merge keys (opt in with
+ * `aliases: true`) and only finite numbers. Errors carry the offset, line and column of the YAML that caused them,
+ * including the OPF validation findings mapped back to the YAML of the field they name. The writer emits canonical schema key
+ * order, 2-space block style and quoted ambiguous strings, and reads its own output back before returning it.
+ *
+ * The same input always gives the same output.
+ */
+
+/** The canonical schema URL (`$id` of the presentation schema), used by `schemaComment`. */
+declare const YAML_SCHEMA_URL: string;
+interface FromYamlOptions {
+    /**
+     * Check the result with `validate` and map its findings to YAML line and column: `true` (the default) checks `format`
+     * and `references`; options pick other rules or categories (`{}` runs every rule); `false` skips the check.
+     */
+    validate?: boolean | ValidateOptions;
+    /** Catalogs the host registered, for the references check of `validate: true` (the default). Nothing is fetched. */
+    catalogs?: readonly Catalog[];
+    /**
+     * Expand anchors, aliases and `<<` merge keys (default false: they are an error). The expansion is capped at 100 aliases
+     * and an alias inside its own anchor is rejected, so the result is always finite JSON-compatible data.
+     */
+    aliases?: boolean;
+}
+/**
+ * The converted deck with the `validate` report of it, so a YAML file reports exactly what the same deck as JSON text does
+ * (`schemaValid`, `checks`, `template` ...), with every finding located in the YAML. After a YAML syntax or dialect error,
+ * or with `validate: false`, no OPF check ran: `schemaValid` is null and `checks` says so.
+ */
+interface FromYamlResult extends ValidationReport {
+    /** The converted deck. Always an object; when `valid` is false it is a best effort (an empty object after a YAML error). */
+    presentation: Presentation;
+    /** True when there are no errors (YAML errors and OPF validation errors both count). */
+    valid: boolean;
+    /** Findings (the shared Finding format), in source order, each with `location` (UTF-16 offset and length, one-based line and column). */
+    findings: YamlFinding[];
+}
+/**
+ * Convert YAML text to an OPF document. Never throws for malformed content; read `valid` and `findings`. Rule ids
+ * starting `yaml/` are syntax and dialect errors (category `format`); ids starting `opf/` are the `validate` findings of the
+ * parsed deck, located at the YAML node of the field they name. A syntax or dialect error stops there: no OPF check runs. A leading BOM is accepted (offsets count it, columns do not) and so are CRLF line endings.
+ */
+declare function fromYaml(yaml: string, options?: FromYamlOptions): FromYamlResult;
+interface ToYamlOptions {
+    /** Start the file with `# yaml-language-server: $schema=<url>` so editors validate and complete it (default false). The URL is the deck's own `$schema`, else the canonical schema. */
+    schemaComment?: boolean;
+}
+interface ToYamlResult {
+    yaml: string;
+}
+/** Raised by `toYaml`: `invalid-document` (does not validate as OPF) or `not-representable` (a value YAML cannot carry exactly; a bug). */
+declare class OPFYamlError extends Error {
+    readonly code: "invalid-document" | "not-representable";
+    readonly details: Record<string, unknown>;
+    constructor(code: "invalid-document" | "not-representable", message: string, details?: Record<string, unknown>);
+}
+/**
+ * Convert an OPF document to canonical YAML: schema key order, 2-space block style, no line folding, strings that would
+ * read as another type or in another YAML version quoted. The text is read back and compared before it is returned, so
+ * `fromYaml(toYaml(doc).yaml).presentation` deep-equals `doc` (key order aside) and the output converts back to itself byte for byte.
+ * Throws `OPFYamlError` (`invalid-document`) when the input is not valid OPF.
+ */
+declare function toYaml(document: unknown, options?: ToYamlOptions): ToYamlResult;
+/**
+ * Parse YAML text that is not an OPF deck (a JSON Patch, a settings file) in the same strict dialect: any JSON-compatible root,
+ * one document, no tags, anchors (unless `aliases`), duplicate keys or non-finite numbers. Never throws; `value` is `null` when `valid` is false.
+ */
+declare function parseYamlData(yaml: string, options?: {
+    aliases?: boolean;
+}): {
+    value: unknown;
+    valid: boolean;
+    findings: YamlFinding[];
+};
+
+export { type FromYamlOptions, type FromYamlResult, OPFYamlError, type ToYamlOptions, type ToYamlResult, YAML_SCHEMA_URL, type YamlComments, type YamlFinding, fromYaml, parseYamlData, scanYamlComments, toYaml };