@json-to-office/shared 2.5.0 → 3.0.0

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-export { C as ComponentDefinition, a as ComponentSchemaConfig, c as convertToJsonSchema, b as createComponentSchema, d as createComponentSchemaObject, e as exportSchemaToFile, f as fixSchemaReferences } from './schema-utils-C5Qdzsgy.js';
+export { C as ComponentDefinition, a as ComponentSchemaConfig, c as convertToJsonSchema, b as createComponentSchema, d as createComponentSchemaObject, e as exportSchemaToFile, f as fixSchemaReferences } from './schema-utils-B2i75lAT.js';
 export { AddWarningFunction, GenerationWarning } from './types/warnings.js';
-import { F as FontRegistryEntry, c as FontRuntimeOpts, R as ResolvedFontSource, b as ResolvedFont } from './types-kcQwhOlf.js';
-export { D as DEFAULT_VISUAL_DPI, d as FontFamilyNameSchema, e as FontRegistryDefinition, f as FontRegistryEntrySchema, g as FontRegistrySchema, h as FontSource, i as FontSourceSchema, H as HighchartsHeaders, j as HighchartsHeadersResolver, k as HighchartsServiceConfig, M as MAX_RASTERIZE_BATCH_SLIDES, l as MAX_RASTERIZE_FONTS, m as MAX_RASTERIZE_FONT_BYTES, n as MAX_VISUAL_DPI, o as MIN_VISUAL_DPI, P as PptxBatchRasterizer, p as PptxRasterizeBatchRequest, q as PptxRasterizeBatchResult, r as PptxRasterizeBatchSlide, s as PptxRasterizeBatchSlideResult, t as PptxRasterizeFailureStage, u as PptxRasterizeRequest, v as PptxRasterizeResult, w as PptxRasterizer, x as PptxServiceConfig, y as PptxServiceHeaders, z as PptxServiceHeadersResolver, a as RasterizeFontFace, S as SAFE_FONTS, A as SafeFontName, B as ServicesConfig, C as clampVisualDpi, E as isSafeFont } from './types-kcQwhOlf.js';
-export { F as FeatureRequirement, a as FeatureRequirementCollector, O as OfficeFormat, b as OfficeRenderer, R as RENDERER_DEPENDENCY_MISSING, c as RenderOptions, d as RendererDiagnostic, e as RendererDiagnosticSeverity, f as RendererRegistry, g as RendererStatus, h as UnsupportedRendererFeatureError, i as UnsupportedRendererFeatureErrorInit, j as assertNever, k as assertRendererSupports, l as diagnoseUnsupportedFeatures, p as partitionDiagnostics, r as rendererError, m as rendererWarning } from './capabilities-DtPF3aBj.js';
+import { F as FontRegistryEntry, c as FontRuntimeOpts, R as ResolvedFontSource, b as ResolvedFont, a as RasterizeFontFace } from './types-kcQwhOlf.js';
+export { D as DEFAULT_VISUAL_DPI, d as FontFamilyNameSchema, e as FontRegistryDefinition, f as FontRegistryEntrySchema, g as FontRegistrySchema, h as FontSource, i as FontSourceSchema, H as HighchartsHeaders, j as HighchartsHeadersResolver, k as HighchartsServiceConfig, M as MAX_RASTERIZE_BATCH_SLIDES, l as MAX_RASTERIZE_FONTS, m as MAX_RASTERIZE_FONT_BYTES, n as MAX_VISUAL_DPI, o as MIN_VISUAL_DPI, P as PptxBatchRasterizer, p as PptxRasterizeBatchRequest, q as PptxRasterizeBatchResult, r as PptxRasterizeBatchSlide, s as PptxRasterizeBatchSlideResult, t as PptxRasterizeFailureStage, u as PptxRasterizeRequest, v as PptxRasterizeResult, w as PptxRasterizer, x as PptxServiceConfig, y as PptxServiceHeaders, z as PptxServiceHeadersResolver, S as SAFE_FONTS, A as SafeFontName, B as ServicesConfig, C as clampVisualDpi, E as isSafeFont } from './types-kcQwhOlf.js';
+import { O as OfficeFormat } from './capabilities-DtPF3aBj.js';
+export { F as FeatureRequirement, a as FeatureRequirementCollector, b as OfficeRenderer, R as RENDERER_DEPENDENCY_MISSING, c as RenderOptions, d as RendererDiagnostic, e as RendererDiagnosticSeverity, f as RendererRegistry, g as RendererStatus, h as UnsupportedRendererFeatureError, i as UnsupportedRendererFeatureErrorInit, j as assertNever, k as assertRendererSupports, l as diagnoseUnsupportedFeatures, p as partitionDiagnostics, r as rendererError, m as rendererWarning } from './capabilities-DtPF3aBj.js';
 export { DEFAULT_ERROR_CONFIG, ERROR_EMOJIS, ErrorFormatterConfig, calculatePosition, clearComponentNamesCache, createErrorConfig, createJsonParseError, extractStandardComponentNames, formatErrorMessage, formatErrorSummary, getLiteralValue, getObjectSchemaPropertyNames, getSchemaMetadata, groupErrorsByPath, isLiteralSchema, isObjectSchema, isUnionSchema, transformValueError, transformValueErrors } from './validation/unified/index.js';
 export { T as TransformedError, V as ValidationError, a as ValidationResult } from './types-BWFZ7OaO.js';
 export { ComponentValidationError, ComponentValidationResult, ComponentVersion, ComponentVersionMap, CustomComponent, DuplicateComponentError, PluginValidationOptions, PluginValidationResult, RenderContext, RenderFunction, UnknownPreservedComponentError, createComponent, createVersion, getValidationSummary, isValidationSuccess, resolveComponentVersion, validateCustomComponentProps } from './plugin/index.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { Static } from '@sinclair/typebox';
+import { Static, TSchema } from '@sinclair/typebox';
 export { ParsedSemver, compareSemver, isValidSemver, latestVersion, parseSemver } from './utils/semver.js';
 import '@sinclair/typebox/value';
 
@@ -1612,6 +1613,410 @@ declare function resolveDesignColor(value: string, colors: Record<string, string
 /** Reject dangling/cyclic new tokens before they can become invalid OOXML. */
 declare function validateDesignColors(system: DesignSystem, colors: Record<string, string | undefined>): void;
 
+/**
+ * The document's typography, expressed as Highcharts options.
+ *
+ * A `highcharts` component is a PNG drawn by a browser that has never seen the
+ * document, so nothing about the page's type reaches the chart on its own: the
+ * axis labels, title and legend come out in the export server's default face
+ * at Highcharts' own sizes, visibly foreign to the prose around them. The
+ * palette already carries (see `chart-palette.ts`); this carries the type.
+ *
+ * Format-neutral on purpose. Each core reads its own theme shape into a
+ * `ChartTypography` — family, colours and sizes in document points — and this
+ * module turns that into the option paths Highcharts styles text through. An
+ * explicit author value keeps winning, property by property, exactly as
+ * `options.colors` does.
+ *
+ * Sizes are converted from points to chart pixels through the scale the chart
+ * is placed at: a 900px chart set into a 450pt measure shrinks by half, so a
+ * label that must read as 9pt on the page is drawn at 18px.
+ */
+
+interface ChartTypography {
+    /** CSS `font-family` for everything not styled otherwise (see `cssFontFamily`). */
+    bodyFamily: string;
+    /** CSS `font-family` for the chart title. */
+    headingFamily: string;
+    /** `#RRGGBB` for the title, legend and data labels. */
+    textColor: string;
+    /** `#RRGGBB` for axis text, subtitle, caption and credits. */
+    mutedColor: string;
+    /** Axis labels, axis titles, legend, subtitle and data labels, in points. */
+    labelPt: number;
+    /** Weight for legend items and data labels; Highcharts' own default when unset. */
+    labelWeight?: number;
+    /** Chart title, in points. */
+    titlePt: number;
+    /** Chart title weight; Highcharts' own default when unset. */
+    titleWeight?: number;
+    /** Credits (the source line) and caption, in points. */
+    sourcePt: number;
+}
+/** Points per CSS pixel at the 96 dpi both formats assume for an unplaced chart. */
+declare const POINTS_PER_PIXEL_96DPI = 0.75;
+/**
+ * How many document points one chart pixel occupies once the image is placed.
+ * Unknown or degenerate widths fall back to 96 dpi, the size an unscaled
+ * chart has in both formats.
+ */
+declare function chartPointsPerPixel(chartWidthPx: number, placedWidthPt: number | undefined): number;
+type FontCategory = NonNullable<FontRegistryEntry['category']>;
+/**
+ * A CSS `font-family` list: the family, quoted, then the generic it belongs
+ * to — from the registry category when the font is registered, from the
+ * SAFE_FONTS list otherwise — so a face the export server lacks degrades to
+ * the right shape rather than to the browser's default.
+ */
+declare function cssFontFamily(family: string, category?: FontCategory): string;
+/**
+ * `cssFontFamily` bound to a theme: a registered family answers with its
+ * registry category, an unregistered one with what SAFE_FONTS says of it.
+ */
+declare function chartFamilyResolver(theme: unknown): (family: string) => string;
+type Options = Record<string, unknown>;
+/**
+ * The document's typography written into every Highcharts option path that
+ * styles text, beneath whatever the author set. `ptPerPx` is the placement
+ * scale from `chartPointsPerPixel`.
+ */
+declare function withChartTypography<T extends Options>(options: T, typography: ChartTypography, ptPerPx: number): T;
+/**
+ * `@font-face` rules for the faces of `families`, inlined as data URIs, so an
+ * export server draws a registered font from the same bytes the document
+ * stages rather than from whatever its host happens to have installed. The
+ * bytes go only to the export server, which already receives every data
+ * point of the chart. Empty when no face matches.
+ */
+declare function chartFontFaceCss(faces: readonly RasterizeFontFace[], families: readonly string[]): string;
+/**
+ * The `@font-face` rules for `families` written into a chart's `resources.css`
+ * ahead of whatever the author supplied there. Nothing changes when no face
+ * matches, so a chart set in safe fonts posts the same request it always did.
+ */
+declare function withChartFontFaceCss<T extends {
+    resources?: {
+        css?: string;
+    };
+}>(props: T, faces: readonly RasterizeFontFace[], families: readonly string[]): T;
+
+/**
+ * Content roles a definition may assign to a slot. A quality profile reads
+ * them to require or measure content (an action title at most two lines, a
+ * source under every chart); the theme only styles them. No role adds a
+ * requirement on its own.
+ */
+declare const BLOCK_SLOT_ROLES: readonly ["actionTitle", "takeaway", "source", "tracker", "footer"];
+type BlockSlotRole = (typeof BLOCK_SLOT_ROLES)[number];
+interface BlockSlot {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'component';
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+    enum?: (string | number | boolean)[];
+    minItems?: number;
+    maxItems?: number;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    maxWords?: number;
+    oneLine?: boolean;
+    items?: BlockSlot;
+    properties?: Record<string, BlockSlot>;
+    role?: BlockSlotRole;
+}
+/** Definitions are authored data. No concrete block is registered by the core. */
+interface JsonBlockDefinition {
+    description?: string;
+    slots: Record<string, BlockSlot>;
+    body: unknown[];
+    /** DOCX section state, applied before rendering its header and footer. */
+    section?: {
+        tracker?: unknown;
+        header?: unknown[];
+        footer?: unknown[];
+        pageBreak?: boolean;
+        scope?: 'section' | 'following';
+    };
+    /** PPTX slide settings the invocation's slide inherits unless it states its own. */
+    slide?: {
+        background?: unknown;
+        grid?: unknown;
+        notes?: unknown;
+    };
+}
+declare const BlockSlotSchema: TSchema;
+declare const JsonBlockDefinitionSchema: _sinclair_typebox.TUnsafe<JsonBlockDefinition>;
+declare const BlockDefinitionsSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnsafe<JsonBlockDefinition>>;
+declare const BlockInvocationPropsSchema: _sinclair_typebox.TObject<{
+    ref: _sinclair_typebox.TString;
+    slots: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
+}>;
+/** Portable JSON Schema for a single slot, also used by catalog/inspect clients. */
+declare function blockSlotJsonSchema(slot: BlockSlot): Record<string, unknown>;
+
+type Rec$1 = Record<string, unknown>;
+interface BlockIssue {
+    path: string;
+    code: string;
+    message: string;
+}
+declare class BlockEvaluationError extends Error {
+    readonly issues: BlockIssue[];
+    constructor(issues: BlockIssue[]);
+}
+declare const isBlockRecord: (v: unknown) => v is Rec$1;
+declare const blockPointerKey: (s: string) => string;
+declare function blockValueAt(root: unknown, path: string): unknown;
+declare function toAuthoredBlockPointer(map: Readonly<Record<string, string>>, pointer: string): string;
+/**
+ * Props a component placed in a slot may not carry: placement and group
+ * layout belong to the definition. Read by the runtime check below and by the
+ * editor schema that flags them inline.
+ */
+declare const BLOCK_SLOT_PLACEMENT_PROPS: readonly string[];
+declare const blockWordCount: (text: string) => number;
+/** Slot constraints and defaults are shared by validation and evaluation. */
+declare function resolveBlockSlot(slot: BlockSlot, input: unknown, path: string, issues: BlockIssue[]): unknown;
+declare function readBlockDefinitions(document: unknown): Record<string, JsonBlockDefinition>;
+declare function validateBlockDefinitions(definitions: unknown, format: 'docx' | 'pptx', reservedNames?: readonly string[]): BlockIssue[];
+declare function validateBlockInvocations(document: unknown, definitions: Record<string, JsonBlockDefinition>, format: 'docx' | 'pptx', reservedNames?: readonly string[]): BlockIssue[];
+interface BlockEnvironment {
+    slots: Rec$1;
+    slotSources?: Record<string, string>;
+    source: string;
+    definition: string;
+    context: Rec$1;
+    contextSources?: Record<string, string>;
+    item?: unknown;
+    itemSource?: string;
+}
+interface BlockSectionEffect {
+    settings: NonNullable<JsonBlockDefinition['section']>;
+    environment: BlockEnvironment;
+    path: string;
+}
+interface BlockSlideEffect {
+    settings: NonNullable<JsonBlockDefinition['slide']>;
+    environment: BlockEnvironment;
+    path: string;
+}
+interface BlockEvaluatorOptions {
+    format: 'docx' | 'pptx';
+    theme?: unknown;
+    context?: Rec$1;
+    contextSources?: Record<string, string>;
+    reservedNames?: readonly string[];
+    contextAt?: (path: string) => Rec$1;
+    measure?: (axis: 'width' | 'height', unit: 'pt' | 'twip' | 'in', context: Rec$1) => number;
+    onSection?: (effect: BlockSectionEffect) => void;
+    onSlide?: (effect: BlockSlideEffect) => void;
+}
+/** Pure bounded JSON composition. Plugins are expanded by the host, never evaluated here. */
+declare class JsonBlockEvaluator {
+    readonly definitions: Record<string, JsonBlockDefinition>;
+    readonly options: BlockEvaluatorOptions;
+    readonly sourceMap: Record<string, string>;
+    readonly blocks: string[];
+    private nodes;
+    constructor(definitions: Record<string, JsonBlockDefinition>, options: BlockEvaluatorOptions);
+    private guard;
+    evaluate(value: unknown, env: BlockEnvironment, out: string, definitionPath: string, depth?: number): unknown;
+    expand(value: unknown, path?: string, depth?: number): unknown;
+}
+
+declare function blockSlotsJsonSchema(definition: JsonBlockDefinition): Record<string, unknown>;
+/** Authored definitions and fill pointers for exactly this document revision. */
+declare function documentBlockMetadata(document: unknown): {
+    definitions: {
+        name: string;
+        definitionPointer: string;
+        definition: JsonBlockDefinition;
+        slotsSchema: Record<string, unknown>;
+    }[];
+    invocations: {
+        ref: string;
+        path: string;
+        slotsPath: string;
+        defined: boolean;
+    }[];
+    invalidDefinitions: boolean;
+};
+/** Compiled pointer → authored pointer. */
+type BlockSourceMap = Readonly<Record<string, string>>;
+/** A document with every block lowered in place, and how to get back. */
+interface ExpandedBlocks<T> {
+    document: T;
+    sourceMap: BlockSourceMap;
+    /** Authored pointers of every expanded invocation, in document order. */
+    blocks: readonly string[];
+}
+interface BlockSlotBudget {
+    block: string;
+    slot: string;
+    path: string;
+    words: number;
+    maxWords: number;
+}
+interface BlockSlotRoleValue {
+    block: string;
+    /** Authored pointer of the invocation. */
+    invocation: string;
+    slot: string;
+    role: BlockSlotRole;
+    /** Authored pointer of the slot value, whether or not one was supplied. */
+    path: string;
+    /** The resolved value after defaults; undefined when absent. */
+    value: unknown;
+}
+/** Metadata is always read from authored definitions, never from a named catalog. */
+declare function blockSlotBudgets(document: unknown, blocks: readonly string[]): BlockSlotBudget[];
+/**
+ * Every role-bearing slot of every invocation, present or not, so a profile
+ * can require one (a source under a chart) and measure another (an action
+ * title's length) at the authored pointer the author can patch.
+ */
+declare function blockSlotRoles(document: unknown, blocks: readonly string[]): BlockSlotRoleValue[];
+
+type Schema$1 = Record<string, any>;
+/**
+ * Derive authoring from the renderer/plugin schemas without weakening ordinary
+ * documents. Each value retains its literal schema and receives only directives
+ * whose result family can fit. Defaults and conditional branches recurse into
+ * that same value schema; repetition templates use the actual array item schema.
+ *
+ * Dispatch uses standard draft-07 conditionals, not overlapping anyOf branches:
+ * existing literal keys keep literal completion, and a directive selects only
+ * its own options. Empty/incomplete objects offer literal keys and directive
+ * starters. Memoized references keep recursive schemas finite and avoid copying
+ * the component graph into every default/then/else branch.
+ */
+declare function createBlockAuthoringSchema(definitions: Record<string, Schema$1>, componentDefinition: string, excludedComponents?: readonly string[], format?: OfficeFormat): Schema$1;
+
+type Rec = Record<string, unknown>;
+interface BlockCompositionOptions {
+    /** Registered code component names. JSON never loads or installs them. */
+    plugins: ReadonlySet<string>;
+    /** Expand one registered component at its authored path into standard output. */
+    render: (component: Rec, path: string) => Promise<unknown[]>;
+    /** Plugin names kept unexpanded in the `preserved` tree (schema export, inspection). */
+    preserve?: ReadonlySet<string>;
+}
+interface BlockComposition {
+    /** Every block and plugin lowered to standard components. */
+    standard: unknown;
+    /** The same tree with preserved plugins left as authored. */
+    preserved: unknown;
+}
+/**
+ * One bounded expansion for document-local JSON and registered code, in both
+ * directions: a plugin can emit a block, a block body or component slot can
+ * name a plugin, and either can nest. Provenance survives each boundary
+ * through the evaluator's source map; emitted output is wrapped in a `group`
+ * whose pointer maps back to the plugin's authored node.
+ *
+ * Format-neutral: the host supplies the evaluator (its format, theme and
+ * context) and validates the finished tree.
+ */
+declare function composeBlocksWithPlugins(evaluator: JsonBlockEvaluator, document: unknown, options: BlockCompositionOptions): Promise<BlockComposition>;
+
+type Schema = Record<string, any>;
+/** A block invocation as authored: the component the editor inserts. */
+interface BlockInvocationExample {
+    name: 'block';
+    props: {
+        ref: string;
+        slots?: Record<string, unknown>;
+    };
+}
+/**
+ * A slot's contract as short facts, in one order, for every place that shows
+ * it: the editor hover, the AI prompt, a catalog summary. "Required" means
+ * the caller must supply a value — a slot with a default never is.
+ */
+declare function blockSlotFacts(slot: BlockSlot): string[];
+/** The hover text for a slot: its description, then its contract in one line. */
+declare function blockSlotMarkdown(slot: BlockSlot): string;
+/**
+ * JSON Schema for one slot as the editor should see it. Unlike the portable
+ * `blockSlotJsonSchema`, a component slot references the real component
+ * definition — so a chart placed in it completes like any other chart — with
+ * the placement props the runtime rejects flagged at the key they appear on.
+ */
+declare function blockSlotEditorSchema(slot: BlockSlot, componentRef?: Schema): Schema;
+/** The `slots` object of an invocation of this definition. */
+declare function blockSlotsEditorSchema(definition: JsonBlockDefinition, componentRef?: Schema): Schema;
+/**
+ * The `props` of a `block` component given this document's definitions:
+ * `ref` enumerates the names with their descriptions, and each name
+ * dispatches `slots` to its own schema. With no definitions the reference
+ * stays a free string — the runtime says which name is missing.
+ */
+declare function blockInvocationPropsSchema(definitions: Record<string, JsonBlockDefinition>, componentRef?: Schema): Schema;
+/** Where the document-aware invocation props go in an exported schema. */
+interface DocumentBlockTarget {
+    /** A component definition under `definitions`, typically one per renderer. */
+    name: string;
+    /**
+     * What a component slot accepts — the content a slide or a section holds,
+     * as a reference into the same schema. Omitted, a component slot only asks
+     * for a `name`.
+     */
+    componentRef?: Schema;
+}
+/**
+ * Install the document-aware invocation props on every `block` branch inside
+ * the targeted component definitions — the definition's own branch and the
+ * copies a container inlines for its children — so an invocation completes
+ * the same wherever a slide or section places it. References out of the
+ * definition are not followed: block bodies live in their own derived
+ * definitions and keep their binding-aware props. Mutates in place; call on
+ * a copy of the shared schema.
+ */
+declare function applyDocumentBlocksToSchema(schema: Schema, definitions: Record<string, JsonBlockDefinition>, targets: readonly DocumentBlockTarget[]): void;
+/**
+ * The definitions a block needs beside itself, dependencies first, so a
+ * copied definition never leaves an unresolved reference behind. Unknown
+ * references and cycles are skipped: the runtime reports those.
+ */
+declare function blockDependencies(definitions: Record<string, JsonBlockDefinition>, name: string): string[];
+/**
+ * A valid invocation to insert: the first one the source document makes, if
+ * it makes one — real content, at the cardinality its author chose — else
+ * one synthesized from the slots at typical cardinality.
+ */
+declare function blockInvocationExample(name: string, definition: JsonBlockDefinition, options: {
+    document?: unknown;
+    format: OfficeFormat;
+}): BlockInvocationExample;
+/** An authoring reference extracted from a complete document. */
+interface BlockReference {
+    name: string;
+    format: OfficeFormat;
+    /** The document the definition comes from. */
+    template: string;
+    definitionPointer: string;
+    description: string;
+    definition: JsonBlockDefinition;
+    /** Portable slot schema, as `jto://blocks` publishes it. */
+    slotsSchema: Record<string, unknown>;
+    /** A valid invocation at typical cardinality. */
+    example: BlockInvocationExample;
+    /** Other definitions of the same document this one invokes, dependencies first. */
+    dependencies: string[];
+}
+/**
+ * Every block a complete document defines, as a reference an editor or an
+ * agent can copy: definition, dependencies and a working invocation. A
+ * document whose definitions do not validate contributes nothing — a
+ * reference must be copyable as is.
+ */
+declare function blockReferencesFromDocument(document: unknown, source: {
+    template: string;
+    format: OfficeFormat;
+}): BlockReference[];
+
 /**
  * Deep Merge Utilities
  * Generic deep-merge helpers used by both docx and pptx
@@ -1625,4 +2030,4 @@ declare function validateDesignColors(system: DesignSystem, colors: Record<strin
  */
 declare function mergeWithDefaults<T>(userConfig: T, themeDefaults: Partial<T>): T;
 
-export { CANVASES, ChromeSchema, DEFAULT_CHART_THEME_COLORS, type DesignCanvas, DesignSpacingSchema, type DesignSystem, DesignSystemProperties, DesignSystemSchema, FONT_URL_ALLOWLIST, type FontIssueCode, FontRegistry, FontRegistryEntry, type FontRegistryInput, type FontResolutionIssue, FontRuntimeOpts, type FontSubstitution, type FontValidationInput, type FontValidationResult, MotifSchema, POPULAR_GOOGLE_FONTS, PaletteSchema, type PopularGoogleFont, ROLE_SCALE_STEPS, ResolvedFont, ResolvedFontSource, type SynthesizedFamily, TYPE_ROLES, TextCaseSchema, type TypeRole, type TypeRoleName, TypeRoleNameSchema, TypeRoleSchema, TypeRolesSchema, TypographySchema, UPSTREAM_OVERRIDES, type UpstreamOverride, type UpstreamVariant, WEIGHT_LABELS, applyExportMode, applyFontSubstitution, buildDefaultSubstitutionMap, capsFormatting, collectFontNamesFromDocx, collectFontNamesFromPptx, defaultSubstituteFor, designCanvas, designColors, detectFontFormat, documentFontRegistry, fetchGoogleFontSources, getUpstreamOverride, isAllowedFontUrl, mergeFontRegistries, mergeWithDefaults, resolveDesignColor, resolveTypeRoles, restructureNameDiscriminatedUnions, rewriteFontFamilyName, synthesizeFamilyName, themeFontRegistry, unionBranches, validateDesignColors, validateFontReferences };
+export { BLOCK_SLOT_PLACEMENT_PROPS, BLOCK_SLOT_ROLES, type BlockComposition, type BlockCompositionOptions, BlockDefinitionsSchema, type BlockEnvironment, BlockEvaluationError, type BlockEvaluatorOptions, type BlockInvocationExample, BlockInvocationPropsSchema, type BlockIssue, type BlockReference, type BlockSectionEffect, type BlockSlideEffect, type BlockSlot, type BlockSlotBudget, type BlockSlotRole, type BlockSlotRoleValue, BlockSlotSchema, type BlockSourceMap, CANVASES, type ChartTypography, ChromeSchema, DEFAULT_CHART_THEME_COLORS, type DesignCanvas, DesignSpacingSchema, type DesignSystem, DesignSystemProperties, DesignSystemSchema, type DocumentBlockTarget, type ExpandedBlocks, FONT_URL_ALLOWLIST, type FontIssueCode, FontRegistry, FontRegistryEntry, type FontRegistryInput, type FontResolutionIssue, FontRuntimeOpts, type FontSubstitution, type FontValidationInput, type FontValidationResult, type JsonBlockDefinition, JsonBlockDefinitionSchema, JsonBlockEvaluator, MotifSchema, OfficeFormat, POINTS_PER_PIXEL_96DPI, POPULAR_GOOGLE_FONTS, PaletteSchema, type PopularGoogleFont, ROLE_SCALE_STEPS, RasterizeFontFace, ResolvedFont, ResolvedFontSource, type SynthesizedFamily, TYPE_ROLES, TextCaseSchema, type TypeRole, type TypeRoleName, TypeRoleNameSchema, TypeRoleSchema, TypeRolesSchema, TypographySchema, UPSTREAM_OVERRIDES, type UpstreamOverride, type UpstreamVariant, WEIGHT_LABELS, applyDocumentBlocksToSchema, applyExportMode, applyFontSubstitution, blockDependencies, blockInvocationExample, blockInvocationPropsSchema, blockPointerKey, blockReferencesFromDocument, blockSlotBudgets, blockSlotEditorSchema, blockSlotFacts, blockSlotJsonSchema, blockSlotMarkdown, blockSlotRoles, blockSlotsEditorSchema, blockSlotsJsonSchema, blockValueAt, blockWordCount, buildDefaultSubstitutionMap, capsFormatting, chartFamilyResolver, chartFontFaceCss, chartPointsPerPixel, collectFontNamesFromDocx, collectFontNamesFromPptx, composeBlocksWithPlugins, createBlockAuthoringSchema, cssFontFamily, defaultSubstituteFor, designCanvas, designColors, detectFontFormat, documentBlockMetadata, documentFontRegistry, fetchGoogleFontSources, getUpstreamOverride, isAllowedFontUrl, isBlockRecord, mergeFontRegistries, mergeWithDefaults, readBlockDefinitions, resolveBlockSlot, resolveDesignColor, resolveTypeRoles, restructureNameDiscriminatedUnions, rewriteFontFamilyName, synthesizeFamilyName, themeFontRegistry, toAuthoredBlockPointer, unionBranches, validateBlockDefinitions, validateBlockInvocations, validateDesignColors, validateFontReferences, withChartFontFaceCss, withChartTypography };