@openpresentation/opf 0.14.0 → 0.15.1

package/dist/{finding-C_por275.d.ts → finding-CT_f_vbD.d.ts}

@@ -133,7 +133,7 @@ interface FindingSuggestion {
     value: (string | number | boolean | null);
     label: string;
     /**
-     * Where the suggestion comes from: `schema`, `built-in`, `loaded`, `document` or `contract`.
+     * Where the suggestion comes from: `schema`, `document` (a record the document embeds), `registered` (a catalog the host registered) or `contract`.
      */
     origin: string;
     /**
@@ -209,4 +209,4 @@ interface ValidationIssue {
     };
 }
 
-export type { Finding as F, JsonPatchOperation as J, ValidationIssue as V, FindingCategory as a, FindingFix as b, FindingFocus as c, FindingLocation as d, FindingReport as e, FindingSeverity as f, FindingSuggestion as g };
+export type { FindingReport as F, JsonPatchOperation as J, ValidationIssue as V, Finding as a, FindingLocation as b, FindingSeverity as c, FindingCategory as d, FindingFix as e, FindingFocus as f, FindingSuggestion as g };

package/dist/format.js

@@ -1,2 +1,2 @@
-export { OPFFormatError, format, isFormatted, sortPresentationKeys } from './chunk-5ZU6JAPP.js';
-import './chunk-LS2FMPI5.js';
+export { OPFFormatError, format, isFormatted, sortPresentationKeys } from './chunk-ZPU46TFA.js';
+import './chunk-2CJPC4HI.js';

package/dist/index.d.ts

@@ -1,23 +1,229 @@
-export { a as SchemaEntry, S as SchemaName, b as audience, c as chartType, d as colorScheme, f as fontScheme, l as language, e as layout, n as narrative, p as presentation, g as purpose, s as schemaEntries, h as schemaNames, i as schemas, j as socialPlatform, t as theme, k as tone } from './schemas-DDpqAgyS.js';
-import { C as CatalogKind } from './catalogs-D-yyQWCQ.js';
-export { A as Audience, e as CatalogEntry, f as CatalogIndex, g as CatalogIndexRecord, h as CatalogRecord, a as ChartType, b as ColorScheme, F as FontScheme, L as Language, c as Layout, N as Narrative, P as Purpose, S as SocialPlatform, T as Theme, d as Tone, i as audiences, j as catalogEntries, k as catalogIndexes, l as catalogKinds, m as catalogSchemaNames, n as catalogs, o as chartTypes, p as colorSchemes, q as fontSchemes, r as languages, s as layouts, t as narratives, u as purposes, v as socialPlatforms, w as themes, x as tones } from './catalogs-D-yyQWCQ.js';
+export { SchemaEntry, SchemaName, audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './schemas.js';
 export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationRules } from './validator.js';
-export { B as BuiltinVariableInfo, C as Contract, D as DEFAULT_VARIABLE_DATE_FORMAT, O as OPFVariableError, R as ResolveVariablesOptions, b as ResolveVariablesResult, c as VARIABLE_KINDS, d as ValidateFonts, V as ValidateOptions, e as ValidationCategory, f as ValidationChecks, a as ValidationReport, g as ValidationRuleCost, h as ValidationRuleInfo, i as ValidationThresholds, j as VariableDeclaration, k as VariableDiagnostic, l as VariableDiagnosticCode, m as VariableDiagnosticSeverity, n as VariableInfo, o as VariableKind, p as VariableUse, q as VariableUseForm, r as VariableValues, s as coerceVariableValue, t as formatVariableNumber, u as hasContentVariables, v as isTemplate, w as listBuiltinVariables, x as listVariables, y as resolveVariables, z as validationCategories, A as variableDeclarations } from './validation-types-zh03LeZy.js';
+export { B as BuiltinVariableInfo, C as Contract, D as DEFAULT_VARIABLE_DATE_FORMAT, O as OPFVariableError, R as ResolveVariablesOptions, b as ResolveVariablesResult, c as VARIABLE_KINDS, d as ValidateFonts, V as ValidateOptions, e as ValidationCategory, f as ValidationChecks, a as ValidationReport, g as ValidationRuleCost, h as ValidationRuleInfo, i as ValidationThresholds, j as VariableDeclaration, k as VariableDiagnostic, l as VariableDiagnosticCode, m as VariableDiagnosticSeverity, n as VariableInfo, o as VariableKind, p as VariableUse, q as VariableUseForm, r as VariableValues, s as coerceVariableValue, t as formatVariableNumber, u as hasContentVariables, v as isTemplate, w as listBuiltinVariables, x as listVariables, y as resolveVariables, z as validationCategories, A as variableDeclarations } from './validation-types-BOcY9GTs.js';
 export { SpecFileEntry, SpecFileKind, SpecFilePath, specFileEntries, specFileKinds, specFilePaths } from './spec-files.js';
-export { LayoutPreviewIndex, LayoutPreviewRecord, getLayoutPreview, hasLayoutPreview, layoutPreviewIndex, layoutPreviewSlugs, layoutPreviews } from './previews.js';
-export { P as Presentation } from './presentation-C5eHkevA.js';
-export { F as Finding, a as FindingCategory, b as FindingFix, c as FindingFocus, d as FindingLocation, e as FindingReport, f as FindingSeverity, g as FindingSuggestion, J as JsonPatchOperation, V as ValidationIssue } from './finding-C_por275.js';
-export { C as ComposeSlideOptions, F as FontFamilies, a as FontSchemeDiagnostic, b as Fonts, L as LanguageFamilyName, c as LayoutDiagnostic, M as MeasureTextWidth, T as TextMeasurement, d as TextStyle, n as normalizeLanguageFamily } from './composition-_WEwBe2a.js';
-export { O as OPFPaginationError, P as PaginatedPage, a as PaginationMapping, b as PaginationOptions, c as PaginationResult, d as PresentationPaginationOptions, e as PresentationPaginationResult, S as SlideContext, f as SlideContextDiagnostic, g as SlideContextOptions, h as SlideContextReferenceDiagnostic, p as paginate, i as paginateSlide, r as resolveSlideContext } from './pagination-BZpXLvFL.js';
+import { P as Presentation } from './presentation-CDKQVkyI.js';
+export { Audience, ChartType, ColorScheme, FontScheme, Language, Layout, Narrative, Purpose, SocialPlatform, Theme, Tone } from './types.js';
+import { C as CatalogKind, U as UnresolvedReferenceDiagnostic, b as CatalogOptions, a as Catalog, R as RecordProvenance } from './catalog-refs-BSfGELpt.js';
+export { c as CATALOG_GROUP_PATTERN, d as CATALOG_REFERENCE_PATTERN, e as CatalogRecordMap, f as CatalogRecords, g as CatalogReferenceSite, O as OPFCatalogsOptionError, h as OPFUnresolvedReferenceError, i as ResolvedReference, j as catalogGroupSource, k as catalogKinds, l as catalogRecords, m as catalogReferenceSites, p as parseReference, r as resolveReference, u as unresolvedReference } from './catalog-refs-BSfGELpt.js';
+export { a as Finding, d as FindingCategory, e as FindingFix, f as FindingFocus, b as FindingLocation, F as FindingReport, c as FindingSeverity, g as FindingSuggestion, J as JsonPatchOperation, V as ValidationIssue } from './finding-CT_f_vbD.js';
+export { a as CHART_TYPES, C as ComposeSlideOptions, E as ENGINE_DEFAULT_CHART_TYPES, b as ENGINE_DEFAULT_COLOR_SCHEME, c as ENGINE_DEFAULT_FONT_SCHEME, d as ENGINE_DEFAULT_THEME, e as FontFamilies, F as Fonts, f as LANGUAGES, g as LanguageFamilyName, h as LanguageVocabulary, L as LayoutDiagnostic, M as MeasureTextWidth, S as SOCIAL_PLATFORMS, i as SocialPlatformVocabulary, T as TextMeasurement, j as TextStyle, n as normalizeLanguageFamily } from './composition-D2tghM82.js';
+export { C as CatalogDisplayKind, a as CatalogRecordKind, c as catalogDisplayKinds, b as catalogSchemaNames } from './catalog-schemas-CinPh5WA.js';
+export { O as OPFPaginationError, P as PaginatedPage, a as PaginationMapping, b as PaginationOptions, c as PaginationResult, d as PresentationPaginationOptions, e as PresentationPaginationResult, S as SlideContext, f as SlideContextDiagnostic, g as SlideContextOptions, p as paginate, h as paginateSlide, r as resolveSlideContext } from './pagination-wedbe7eq.js';
 export { ApplyPatchOptions, OPFPatchError, OPFPatchValidationError, PatchResult, applyPatch } from './patch.js';
 export { DiffOptions, MergeConflict, MergeOptions, MergeResult, PresentationDiff, diff, merge } from './diff.js';
 export { FormatOptions, OPFFormatError, format } from './format.js';
 export { FromMarkdownOptions, FromMarkdownResult, OPFMarkdownError, ToMarkdownOptions, ToMarkdownResult, fromMarkdown, toMarkdown } from './markdown.js';
 export { DataCell, DataImportOptions, ImportDataOptions, OPFDataImportError, TabularData, importData, parseTabularData } from './data.js';
-export { I as ChartComboSeries, C as ChartMapping, a as ChartNumberFix, b as ChartNumberFixOperation, c as ChartNumberFixOptions, D as DataCellValue, d as DataColumn, e as DataDiagnostic, f as DataDiagnosticCode, g as DataResolveOptions, h as DataSourceRef, i as DataStyledCell, j as DataTableCell, k as DataTableHeader, l as DataTableValue, m as DataTextRun, n as Dataset, o as DatasetRef, R as ResolvedChartData, p as ResolvedTableData, q as chartNumber, r as datasetDiagnostics, s as formatDataNumber, t as fromExcelNumberFormat, u as inlineChartData, v as inlineDatasets, w as inlineTableData, x as isDatasetRef, y as isXYChartType, z as numberFormatError, A as resolveChartData, B as resolveTableData, E as suggestChartNumberFix, F as tableCellDisplayValue, G as toExcelNumberFormat, H as unusedDatasets } from './chart-data-B_3z9VTb.js';
+export { I as ChartComboSeries, C as ChartMapping, a as ChartNumberFix, b as ChartNumberFixOperation, c as ChartNumberFixOptions, D as DataCellValue, d as DataColumn, e as DataDiagnostic, f as DataDiagnosticCode, g as DataResolveOptions, h as DataSourceRef, i as DataStyledCell, j as DataTableCell, k as DataTableHeader, l as DataTableValue, m as DataTextRun, n as Dataset, o as DatasetRef, R as ResolvedChartData, p as ResolvedTableData, q as chartNumber, r as datasetDiagnostics, s as formatDataNumber, t as fromExcelNumberFormat, u as inlineChartData, v as inlineDatasets, w as inlineTableData, x as isDatasetRef, y as isXYChartType, z as numberFormatError, A as resolveChartData, B as resolveTableData, E as suggestChartNumberFix, F as tableCellDisplayValue, G as toExcelNumberFormat, H as unusedDatasets } from './chart-data-BnNqgnC-.js';
 export { FONT_POLICY, FontAvailability, FontAvailabilityCode, FontAvailabilityDiagnostic, FontLicenseClass, FontPolicyDecision, FontPolicyEntry, FontPolicyTable, FontReplacement, FontReplacementCompatibility, FontReplacementMeasurement, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './font-policy.js';
+import './json-BFSdESOE.js';
 
-/** A reference as authored: the string (a catalog id, URL, `pkg:` reference, tag or free text) or the inline record's id. */
+/** Whether two records have the same content once embedded (`$schema`, `id` and `x-*` ignored). */
+declare function sameRecord(a: unknown, b: unknown): boolean;
+/** One record `embed` or `copySlides` added to a document. */
+interface EmbeddedRecord {
+    group: string;
+    kind: CatalogKind;
+    id: string;
+    source?: string;
+}
+interface EmbedResult {
+    document: Presentation;
+    /** The records added, in the order they were embedded. */
+    added: EmbeddedRecord[];
+    /** The references that resolve nowhere: they stay as written. */
+    unresolved: UnresolvedReferenceDiagnostic[];
+}
+/**
+ * Embed every record the document references, once, in the group it resolves in, together with the records those
+ * records reference (a theme's colour and font schemes). A bare id that resolves in the host's default catalog is
+ * embedded under `catalogs.default` (whose `source` is set to that catalog's). Records already embedded are kept as
+ * they are; catalog display metadata (`x-*`), `$schema` and `id` are stripped from the copies. Idempotent.
+ */
+declare function embed(document: unknown, options?: CatalogOptions): EmbedResult;
+/** A copied record that did not keep its reference. */
+interface CopiedRecordRename {
+    kind: CatalogKind;
+    /** The reference in the source document. */
+    from: string;
+    /** The reference the copied slides use in the target. */
+    to: string;
+    /**
+     * `custom-conflict`: the target's own record of that id differs (or the id is taken); `catalog-revision`: the target
+     * holds a different revision of the same catalog record, so the incoming one moved to `custom`.
+     */
+    reason: 'custom-conflict' | 'catalog-revision';
+}
+interface CopySlidesResult {
+    /** The new target document; `to` is not mutated. */
+    document: Presentation;
+    /** Indexes of the copied slides in the target. */
+    slides: number[];
+    /** Every record this call created under another id (`<id>-2` and up), so an author can review it. A reference rewritten to a record an earlier copy created, which this call reuses, is not a rename and is not listed. */
+    renamed: CopiedRecordRename[];
+    /** Catalog groups the target did not have, added for the copied records. */
+    addedGroups: {
+        name: string;
+        source?: string;
+    }[];
+    /** Records added to the target. */
+    added: EmbeddedRecord[];
+    /** References of the copied slides that resolve nowhere in the source: copied as written. */
+    unresolved: UnresolvedReferenceDiagnostic[];
+}
+/**
+ * Copy slides `indexes` of `from` to the end of `to` (or before `options.at`), with the records they reference.
+ * Groups match by `source`, not by name: references are rewritten to the target's name for that source, and a missing
+ * group is added (renamed when its name is taken). A record whose content the target already has is reused. A `custom`
+ * record whose id the target uses for different content is renamed `<id>-2`. A catalog record whose revision differs
+ * from the one the target resolves goes into `custom` as `<id>-2`, so the copied slides look the same, and is listed in
+ * `renamed`.
+ */
+declare function copySlides(from: unknown, to: unknown, indexes: readonly number[], options?: CatalogOptions & {
+    at?: number;
+}): CopySlidesResult;
+/** A reference to update, by kind: `two-column` (a default record) or `acme:hero`. */
+interface CatalogRef {
+    kind: CatalogKind;
+    reference: string;
+}
+/** One embedded record whose registered catalog publishes different content. */
+interface CatalogRecordChange {
+    kind: CatalogKind;
+    /** The reference that names it: a bare id for `default`, `name:id` otherwise. */
+    reference: string;
+    group: string;
+    id: string;
+    source: string;
+    /** The record as the document embeds it. */
+    embedded: Record<string, unknown>;
+    /** The catalog's current record, as it would be embedded. */
+    current: Record<string, unknown>;
+}
+/** An RFC 6902 operation of `CatalogUpdate.patch`. */
+interface CatalogPatchOperation {
+    op: 'replace';
+    path: string;
+    value: Record<string, unknown>;
+}
+/** A reviewable update: nothing is applied until the author applies `patch` (core `applyPatch`). */
+interface CatalogUpdate {
+    changes: CatalogRecordChange[];
+    patch: CatalogPatchOperation[];
+}
+/**
+ * Compare the records a document embeds under `default` and its named groups with the current records of the catalogs
+ * registered for their sources. Returns the differences and the patch that would adopt them; never changes the document.
+ * `refs` limits the check to those references. `custom` records belong to the document and are never compared.
+ */
+declare function updateFromCatalog(document: unknown, catalogs: readonly Catalog[], refs?: readonly CatalogRef[]): CatalogUpdate;
+/** Where a moved record was and where it is now. */
+interface MovedRecord {
+    kind: CatalogKind;
+    group: string;
+    id: string;
+    /** The reference that names it there: a bare id under `default` and `custom`, `name:id` in a named group. */
+    reference: string;
+}
+/** Error codes of OPFMoveToCustomError. */
+type MoveToCustomErrorCode = 'invalid-reference' | 'already-custom' | 'not-embedded' | 'invalid-id';
+declare class OPFMoveToCustomError extends Error {
+    readonly code: MoveToCustomErrorCode;
+    constructor(code: MoveToCustomErrorCode, message: string);
+}
+/** An RFC 6902 operation of `MoveToCustomResult.patch`. */
+type MoveToCustomPatchOperation = {
+    op: 'add';
+    path: string;
+    value: unknown;
+} | {
+    op: 'remove';
+    path: string;
+} | {
+    op: 'replace';
+    path: string;
+    value: string;
+};
+interface MoveToCustomResult {
+    /** The new document; the input is not mutated. */
+    document: Presentation;
+    from: MovedRecord;
+    to: MovedRecord;
+    /** The references rewritten to name the moved record, as JSON Pointers into the document. */
+    references: string[];
+    /** RFC 6902 operations that turn the input into `document` (apply with core `applyPatch`, for undo and review). */
+    patch: MoveToCustomPatchOperation[];
+    /** Present when `custom` already held a different record under the wanted id, so the record took `<id>-2` (and up). */
+    renamed?: {
+        from: string;
+        to: string;
+    };
+}
+/**
+ * Move an embedded record from `catalogs.default` or a named group into `catalogs.custom`: the fix that
+ * `opf/catalog-record-not-in-source` suggests for a record the group's catalog does not publish. Every reference that
+ * resolved to the record (on slides, in the deck, inside other embedded records) is rewritten to name it in `custom`,
+ * and the record's own references keep naming the records they named. The record keeps its id unless `custom` already
+ * holds a different record under it, when it becomes `<id>-2` (and up); an identical custom record is reused.
+ *
+ * Fork: with `id`, the record is copied into `custom` under that id instead (an editor calls this on the first edit of a
+ * record under `default` or a named group, then applies the edit to the copy). Every reference is rewritten to the copy,
+ * so nothing references the original any more and it is dropped from its group. A different custom record under the
+ * wanted id (the record's own, or `id`) makes it `<id>-2` and up, reported in `renamed`; an identical one is reused.
+ *
+ * Throws OPFMoveToCustomError (`invalid-reference`, `already-custom`, `not-embedded`, `invalid-id`).
+ * Registered catalogs only matter for how the surrounding references resolve, so pass the host's `catalogs` as for
+ * validate.
+ */
+declare function moveToCustom(document: unknown, ref: CatalogRef, options?: CatalogOptions & {
+    id?: string;
+}): MoveToCustomResult;
+
+/**
+ * The theme, colour scheme and font scheme one slide (or the deck) is drawn with, resolved the one way every engine
+ * resolves them: the slide's design, then the deck's design, then the theme, then the engine default, per field.
+ * Catalog-free: records come from the document's catalogs groups and the catalogs the host registered.
+ */
+type Rec = Record<string, unknown>;
+interface ResolvedDesignRecords {
+    theme: Rec;
+    colorScheme: Rec;
+    fontScheme: Rec;
+    /** Where the theme reference is written, dotted (`design.theme`, `slides.2.design.theme`). */
+    themePath: string;
+    /** Where the colour-scheme reference that applies is written, dotted. */
+    colorSchemePath: string;
+    /** Where the font-scheme reference that applies is written, dotted. */
+    fontSchemePath: string;
+    /** The font-scheme reference that applies (a string, or the `id` of an object reference), if any. */
+    fontSchemeReference?: string;
+    /**
+     * Where each record came from (group, source, `document` or `host`), so an engine records provenance without
+     * resolving again. A kind is absent when its engine default applies (no reference, or one that resolves nowhere).
+     */
+    provenance: {
+        theme?: RecordProvenance;
+        colorScheme?: RecordProvenance;
+        fontScheme?: RecordProvenance;
+    };
+    /** Unresolved references, in the order theme, colour scheme, font scheme. */
+    diagnostics: UnresolvedReferenceDiagnostic[];
+}
+/**
+ * The design records slide `slideIndex` is drawn with (the deck's own when `slideIndex` is undefined). Never throws for
+ * an unresolved reference: the engine default applies and `diagnostics` names the reference.
+ */
+declare function resolveDesignRecords(document: unknown, slideIndex: number | undefined, options?: CatalogOptions): ResolvedDesignRecords;
+/** Resolve a font-scheme reference (a string, or an object with an optional `id` plus overrides) on its own. */
+declare function resolveFontScheme(document: unknown, reference: unknown, path: string, options?: CatalogOptions & {
+    group?: string;
+}): {
+    scheme: Rec;
+    diagnostics: UnresolvedReferenceDiagnostic[];
+};
+
+/** A reference as authored: the string (a bare id, `name:id`, a tag or free text) or the inline object's id. */
 interface ReferenceFact {
     id: string | null;
     inline: boolean;
@@ -189,7 +395,7 @@ interface PresentationStats {
         declaredMinutes: number | null;
     };
     images: {
-        /** Image payloads and slide images (`design.slideImage`). */
+        /** Image payloads (image blocks and `Slide.image`). */
         content: {
             total: number;
             withAlt: number;
@@ -283,9 +489,9 @@ interface PresentationStats {
     fonts: {
         /** Every family named: by a font scheme in effect, an inline scheme, or a run's `fontFamily`. */
         families: string[];
-        /** Font-scheme ids in effect (deck and slide overrides). */
+        /** Font-scheme references in effect (deck and slide overrides). */
         schemeIds: string[];
-        /** Ids that match no inline or bundled record. */
+        /** References that resolve nowhere (opf/unresolved-reference); the engine default font scheme is used for them. */
         unresolvedSchemeIds: string[];
         runOverrides: string[];
     };
@@ -298,15 +504,15 @@ interface PresentationStats {
     };
     /** Keys under `extensions` on the deck, slides and payloads. */
     extensions: string[];
-    /** Per-kind inline catalog overrides. */
-    catalogOverrides: Record<string, {
-        records: number;
+    /** The catalog groups the document embeds records in: each group's source and its record count per kind. */
+    catalogs: Record<string, {
         source: string | null;
+        records: Record<string, number>;
     }>;
     /** Present only with `perSlide: true`. */
     perSlide?: SlideStats[];
 }
-interface StatsOptions {
+interface StatsOptions extends CatalogOptions {
     /** Add the per-slide breakdown as `perSlide`. */
     perSlide?: boolean;
     /** Variable values to count as filled, as for `resolveVariables`. */
@@ -316,61 +522,4 @@ interface StatsOptions {
 }
 declare function stats(presentation: unknown, options?: StatsOptions): PresentationStats;
 
-/**
- * Local catalog vendoring: resolve every catalog reference a presentation
- * uses and inline the resolved records into `catalogs.<kind>.records`, so the
- * document renders identically with no catalog lookups beyond itself.
- *
- * Resolution is local-only: inline records are kept as-is, ids that belong to
- * a kind's custom `source` are left to that source, and everything else
- * resolves against the bundled default catalogs. Every reference a record
- * carries is chased in turn — whether the record came from the bundled
- * catalogs or was already inline — so no inlined record dangles. Running the
- * bundle twice is a no-op.
- */
-interface BundleReport {
-    /** Record ids inlined by this run, per kind, in output order. */
-    added: Partial<Record<CatalogKind, string[]>>;
-    /** Referenced ids that were already inline in the document, per kind. */
-    alreadyInline: Partial<Record<CatalogKind, string[]>>;
-    /** Kinds left untouched because the document declares a custom source. */
-    keptSources: CatalogKind[];
-    /**
-     * Referenced bare ids that resolve nowhere locally, per kind — listed for
-     * exactly the positions the validator warns about, so `unresolved` means
-     * "the validator would warn about this": the `narrative` string, bare-id `audience` entries (string or `{ id }` form), the
-     * design references `themes`, `colorSchemes` and `fontSchemes` (string or
-     * `{ id }` form, at deck and slide level), and `chart.type`.
-     *
-     * Every other reference — tones, purposes, languages, layouts,
-     * social platforms, and anything reached through a
-     * record rather than written by the author — is still resolved and inlined
-     * when it is found, and skipped in silence when it is not, because the
-     * validator does not warn there either.
-     *
-     * Informational: unknown ids are warnings, never errors.
-     */
-    unresolved: Partial<Record<CatalogKind, string[]>>;
-}
-interface BundleResult {
-    presentation: unknown;
-    report: BundleReport;
-}
-/**
- * Resolve every catalog reference `value` uses and inline the resolved
- * records, returning a new document plus a report of what changed. The input
- * document is not modified.
- *
- * Anything that is not an object, and any document whose `catalogs` is
- * present but not an object, is returned unchanged with an all-empty report:
- * bundling there would have to overwrite that field, and schema-invalid input
- * deserves a defined no-op over silent data loss. The CLI validates before
- * bundling, so only a direct library call can reach that case.
- *
- * Ids that resolve nowhere are reported as unresolved for the positions the
- * validator warns about, and silently skipped elsewhere; see
- * `BundleReport.unresolved`.
- */
-declare function bundle(value: unknown): BundleResult;
-
-export { type BundleReport, type BundleResult, CatalogKind, type DatasetFact, type HeaderFooterFact, type PresentationStats, type ReferenceFact, type SlideSizeFact, type SlideStats, type StatsOptions, type StatsSlideRef, type TableFact, bundle, stats };
+export { Catalog, CatalogKind, CatalogOptions, type CatalogPatchOperation, type CatalogRecordChange, type CatalogRef, type CatalogUpdate, type CopiedRecordRename, type CopySlidesResult, type DatasetFact, type EmbedResult, type EmbeddedRecord, type HeaderFooterFact, type MoveToCustomErrorCode, type MoveToCustomPatchOperation, type MoveToCustomResult, type MovedRecord, OPFMoveToCustomError, Presentation, type PresentationStats, RecordProvenance, type ReferenceFact, type ResolvedDesignRecords, type SlideSizeFact, type SlideStats, type StatsOptions, type StatsSlideRef, type TableFact, UnresolvedReferenceDiagnostic, copySlides, embed, moveToCustom, resolveDesignRecords, resolveFontScheme, sameRecord, stats, updateFromCatalog };