@json-to-office/shared-docx 1.0.0 → 1.2.0

package/dist/chunk-OP5PCDNN.js

@@ -0,0 +1,1272 @@
+import {
+  AlignmentSchema,
+  FloatingPropertiesSchema,
+  HeadingLevelSchema,
+  IndentSchema,
+  JustifiedAlignmentSchema,
+  LineSpacingSchema,
+  ListSpacingSchema,
+  ParagraphIndentSchema,
+  SpacingSchema,
+  TabStopsSchema
+} from "./chunk-VX2J2KWA.js";
+import {
+  FontDefinitionSchema,
+  HexColorOrTransparentSchema,
+  HexColorSchema,
+  LanguageSchema,
+  NoProofSchema,
+  NoProofWordsSchema
+} from "./chunk-7TTAAYQ5.js";
+
+// src/schemas/component-defaults.ts
+import { Type as Type12 } from "@sinclair/typebox";
+
+// src/schemas/components/heading.ts
+import { Type as Type3 } from "@sinclair/typebox";
+
+// src/schemas/components/revision.ts
+import { Type } from "@sinclair/typebox";
+var RevisionSegmentSchema = Type.Object(
+  {
+    type: Type.Union(
+      [Type.Literal("equal"), Type.Literal("insert"), Type.Literal("delete")],
+      {
+        description: "Segment kind: 'equal' renders as normal text, 'insert' as a tracked insertion, 'delete' as a tracked deletion"
+      }
+    ),
+    text: Type.String({
+      description: "Literal text of this segment (rendered without markdown)"
+    })
+  },
+  {
+    description: "A contiguous run of text sharing one revision state",
+    additionalProperties: false
+  }
+);
+var RevisionSchema = Type.Object(
+  {
+    author: Type.Optional(
+      Type.String({
+        description: 'Revision author shown in Word (default: "json-to-office")'
+      })
+    ),
+    date: Type.Optional(
+      Type.String({
+        format: "date-time",
+        description: "Revision timestamp (ISO 8601). Defaults to the Unix epoch for deterministic output"
+      })
+    ),
+    segments: Type.Array(RevisionSegmentSchema, {
+      minItems: 1,
+      description: "Ordered text segments; concatenating equal+insert segments yields the new text, equal+delete the old text"
+    })
+  },
+  {
+    description: "Tracked-change data: renders the component text as native Word revisions (accept/reject in Word)",
+    additionalProperties: false
+  }
+);
+var RevisionMarkSchema = Type.Object(
+  {
+    type: Type.Union([Type.Literal("insert"), Type.Literal("delete")], {
+      description: "Whether the element was inserted or deleted"
+    }),
+    author: Type.Optional(
+      Type.String({
+        description: 'Revision author shown in Word (default: "json-to-office")'
+      })
+    ),
+    date: Type.Optional(
+      Type.String({
+        format: "date-time",
+        description: "Revision timestamp (ISO 8601). Defaults to the Unix epoch for deterministic output"
+      })
+    )
+  },
+  {
+    description: "Structural tracked change: the element itself was inserted or deleted",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/comment.ts
+import { Type as Type2 } from "@sinclair/typebox";
+var CommentBodyFields = {
+  text: Type2.String({
+    minLength: 1,
+    description: "Comment body. Newlines split it into separate paragraphs in the comment pane."
+  }),
+  author: Type2.Optional(
+    Type2.String({
+      description: 'Comment author shown in Word (default: "json-to-office")'
+    })
+  ),
+  initials: Type2.Optional(
+    Type2.String({
+      description: "Author initials shown on the comment bubble (derived from the author when omitted)"
+    })
+  ),
+  date: Type2.Optional(
+    Type2.String({
+      format: "date-time",
+      description: "Comment timestamp (ISO 8601). Defaults to the Unix epoch for deterministic output"
+    })
+  )
+};
+var CommentReplySchema = Type2.Object(CommentBodyFields, {
+  description: "A reply within a comment thread",
+  additionalProperties: false
+});
+var CommentSchema = Type2.Object(
+  {
+    ...CommentBodyFields,
+    replies: Type2.Optional(
+      Type2.Array(CommentReplySchema, {
+        minItems: 1,
+        description: "Replies, in order. They anchor to the same text and Word shows them as one thread."
+      })
+    ),
+    resolved: Type2.Optional(
+      Type2.Boolean({
+        description: "Mark the whole thread resolved (w15:done). Word writes the thread state only when the document contains at least one reply."
+      })
+    )
+  },
+  {
+    description: "A Word review comment anchored to this component's text",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/heading.ts
+var HeadingPropsSchema = Type3.Object(
+  {
+    text: Type3.String({
+      description: "Heading text (required)"
+    }),
+    level: Type3.Optional(HeadingLevelSchema),
+    // Local font override: allows customizing family/size/color/bold/italic/underline
+    // without modifying theme styles. Supports partial overrides.
+    font: Type3.Optional(Type3.Partial(FontDefinitionSchema)),
+    // Local language override (BCP-47). Falls back to the document default when omitted.
+    language: Type3.Optional(LanguageSchema),
+    // Disable spell/grammar checking for this heading's text
+    noProof: Type3.Optional(NoProofSchema),
+    // Known-words allowlist for this heading (merged with the document list)
+    noProofWords: Type3.Optional(NoProofWordsSchema),
+    alignment: Type3.Optional(JustifiedAlignmentSchema),
+    spacing: Type3.Optional(SpacingSchema),
+    // Paragraph indentation (w:ind) in twips
+    indent: Type3.Optional(ParagraphIndentSchema),
+    lineSpacing: Type3.Optional(
+      Type3.Union([Type3.Number({ minimum: 0 }), LineSpacingSchema])
+    ),
+    pageBreak: Type3.Optional(
+      Type3.Boolean({
+        description: "Insert page break before heading"
+      })
+    ),
+    columnBreak: Type3.Optional(
+      Type3.Boolean({
+        description: "Insert column break before heading"
+      })
+    ),
+    numbering: Type3.Optional(
+      Type3.Boolean({
+        description: "Number this heading with the document's multilevel heading numbering (1., 1.1., 1.1.1.). Set globally via componentDefaults.heading.numbering; false opts a single heading out."
+      })
+    ),
+    keepNext: Type3.Optional(
+      Type3.Boolean({
+        description: "Keep heading with next paragraph on same page"
+      })
+    ),
+    keepLines: Type3.Optional(
+      Type3.Boolean({
+        description: "Keep all lines of heading together on same page"
+      })
+    ),
+    revision: Type3.Optional(RevisionSchema),
+    comment: Type3.Optional(CommentSchema)
+  },
+  {
+    description: "Heading component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/paragraph.ts
+import { Type as Type5 } from "@sinclair/typebox";
+
+// src/schemas/components/note.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var NoteSchema = Type4.Object(
+  {
+    id: Type4.String({
+      minLength: 1,
+      pattern: "^[^\\]\\s]+$",
+      description: 'Marker id referenced from the text as `[^id]`. Any characters except whitespace and "]".'
+    }),
+    text: Type4.String({
+      minLength: 1,
+      description: "Note body. Newlines split it into separate paragraphs where the note is placed."
+    })
+  },
+  {
+    description: "A note body bound to an inline `[^id]` marker",
+    additionalProperties: false
+  }
+);
+var FootnotesSchema = Type4.Array(NoteSchema, {
+  description: "Footnote bodies for `[^id]` markers in this paragraph, placed at the foot of the page. An unreferenced body is not emitted.",
+  minItems: 1
+});
+var EndnotesSchema = Type4.Array(NoteSchema, {
+  description: "Endnote bodies for `[^id]` markers in this paragraph, collected at the end of the document. An unreferenced body is not emitted.",
+  minItems: 1
+});
+
+// src/schemas/components/paragraph.ts
+var FrameWrapTypeSchema = Type5.Union(
+  [
+    Type5.Literal("around"),
+    Type5.Literal("none"),
+    Type5.Literal("notBeside"),
+    Type5.Literal("through"),
+    Type5.Literal("tight"),
+    Type5.Literal("auto")
+  ],
+  {
+    description: "Frame text wrapping type"
+  }
+);
+var FrameAnchorTypeSchema = Type5.Union(
+  [Type5.Literal("margin"), Type5.Literal("page"), Type5.Literal("text")],
+  {
+    description: "Frame anchor type"
+  }
+);
+var FrameHorizontalAlignSchema = Type5.Union(
+  [
+    Type5.Literal("left"),
+    Type5.Literal("center"),
+    Type5.Literal("right"),
+    Type5.Literal("inside"),
+    Type5.Literal("outside")
+  ],
+  {
+    description: "Frame horizontal alignment"
+  }
+);
+var FrameVerticalAlignSchema = Type5.Union(
+  [
+    Type5.Literal("top"),
+    Type5.Literal("center"),
+    Type5.Literal("bottom"),
+    Type5.Literal("inside"),
+    Type5.Literal("outside")
+  ],
+  {
+    description: "Frame vertical alignment"
+  }
+);
+var FloatingFramePropertiesSchema = Type5.Object(
+  {
+    horizontalPosition: Type5.Optional(
+      Type5.Object(
+        {
+          relative: Type5.Optional(FrameAnchorTypeSchema),
+          align: Type5.Optional(FrameHorizontalAlignSchema),
+          offset: Type5.Optional(
+            Type5.Union([
+              Type5.Number({
+                description: "Horizontal offset in twips (1/20 of a point)"
+              }),
+              Type5.String({
+                pattern: "^\\d+(\\.\\d+)?%$",
+                description: 'Horizontal offset as percentage (e.g., "50%") relative to page or margin width'
+              })
+            ])
+          )
+        },
+        {
+          description: "Horizontal positioning (use either align or offset, not both)",
+          additionalProperties: false
+        }
+      )
+    ),
+    verticalPosition: Type5.Optional(
+      Type5.Object(
+        {
+          relative: Type5.Optional(FrameAnchorTypeSchema),
+          align: Type5.Optional(FrameVerticalAlignSchema),
+          offset: Type5.Optional(
+            Type5.Union([
+              Type5.Number({
+                description: "Vertical offset in twips (1/20 of a point)"
+              }),
+              Type5.String({
+                pattern: "^\\d+(\\.\\d+)?%$",
+                description: 'Vertical offset as percentage (e.g., "50%") relative to page or margin height'
+              })
+            ])
+          )
+        },
+        {
+          description: "Vertical positioning (use either align or offset, not both)",
+          additionalProperties: false
+        }
+      )
+    ),
+    wrap: Type5.Optional(
+      Type5.Object(
+        {
+          type: FrameWrapTypeSchema
+        },
+        {
+          description: "Text wrapping configuration",
+          additionalProperties: false
+        }
+      )
+    ),
+    lockAnchor: Type5.Optional(
+      Type5.Boolean({
+        description: "Lock the anchor position"
+      })
+    ),
+    width: Type5.Optional(
+      Type5.Number({
+        minimum: 1,
+        description: "Frame width in twips (DXA units)"
+      })
+    ),
+    height: Type5.Optional(
+      Type5.Number({
+        minimum: 1,
+        description: "Frame height in twips (DXA units)"
+      })
+    )
+  },
+  {
+    description: "Floating text frame properties",
+    additionalProperties: false
+  }
+);
+var AlignmentSchema2 = Type5.Union(
+  [
+    Type5.Literal("left"),
+    Type5.Literal("center"),
+    Type5.Literal("right"),
+    Type5.Literal("justify")
+  ],
+  {
+    description: "Paragraph text alignment"
+  }
+);
+var ParagraphPropsSchema = Type5.Object(
+  {
+    text: Type5.String({
+      description: "Text content (required)"
+    }),
+    // New nested font object, aligned with theme's FontDefinitionSchema
+    // Allow partial overrides (family not required when overriding a subset)
+    font: Type5.Optional(Type5.Partial(FontDefinitionSchema)),
+    // Optional reference to a named style from theme.styles (e.g., 'heading1', 'normal')
+    themeStyle: Type5.Optional(Type5.String()),
+    // Local language override (BCP-47). Falls back to the document default when omitted.
+    language: Type5.Optional(LanguageSchema),
+    // Disable spell/grammar checking for this paragraph's text
+    noProof: Type5.Optional(NoProofSchema),
+    // Known-words allowlist for this paragraph (merged with the document list)
+    noProofWords: Type5.Optional(NoProofWordsSchema),
+    // Rich-text decoration color for bold segments (kept as top-level behavior
+    // option). Same value space as font.color: hex or theme color token.
+    boldColor: Type5.Optional(HexColorSchema),
+    // Paragraph spacing (in points) — limited paragraph-level option allowed
+    spacing: Type5.Optional(SpacingSchema),
+    // Paragraph alignment (moved from font to config level)
+    alignment: Type5.Optional(AlignmentSchema2),
+    // Paragraph indentation (w:ind) in twips
+    indent: Type5.Optional(ParagraphIndentSchema),
+    // Tab stops (w:tabs); tab characters (\t) in text jump to these positions
+    tabStops: Type5.Optional(TabStopsSchema),
+    pageBreak: Type5.Optional(
+      Type5.Boolean({
+        description: "Insert page break before paragraph"
+      })
+    ),
+    columnBreak: Type5.Optional(
+      Type5.Boolean({
+        description: "Insert column break before paragraph"
+      })
+    ),
+    floating: Type5.Optional(FloatingFramePropertiesSchema),
+    keepNext: Type5.Optional(
+      Type5.Boolean({
+        description: "Keep paragraph with next paragraph on same page"
+      })
+    ),
+    keepLines: Type5.Optional(
+      Type5.Boolean({
+        description: "Keep all lines of paragraph together on same page"
+      })
+    ),
+    id: Type5.Optional(
+      Type5.String({
+        description: "Unique identifier for internal linking (bookmark anchor)"
+      })
+    ),
+    revision: Type5.Optional(RevisionSchema),
+    comment: Type5.Optional(CommentSchema),
+    footnotes: Type5.Optional(FootnotesSchema),
+    endnotes: Type5.Optional(EndnotesSchema)
+  },
+  {
+    description: "Paragraph component props (font nested for theme consistency; no flat font properties)",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/image.ts
+import { Type as Type6 } from "@sinclair/typebox";
+var ImagePropsSchema = Type6.Object(
+  {
+    path: Type6.Optional(
+      Type6.String({
+        description: "Image source URL or file path (mutually exclusive with base64 and svg)"
+      })
+    ),
+    base64: Type6.Optional(
+      Type6.String({
+        description: 'Base64-encoded image data in data URI format (e.g., "data:image/png;base64,iVBORw0KGgo...") (mutually exclusive with path and svg)'
+      })
+    ),
+    svg: Type6.Optional(
+      Type6.String({
+        description: 'Raw inline SVG markup, e.g. "<svg xmlns=\\"http://www.w3.org/2000/svg\\" viewBox=\\"0 0 24 24\\">...</svg>" (mutually exclusive with path and base64). Renders as a vector image (Word 2016+); intrinsic size taken from the SVG viewBox/width/height when width/height omitted.'
+      })
+    ),
+    alt: Type6.Optional(
+      Type6.String({
+        description: "Alternative text for accessibility"
+      })
+    ),
+    width: Type6.Optional(
+      Type6.Union(
+        [
+          Type6.Number({
+            minimum: 1,
+            description: "Image width in pixels"
+          }),
+          Type6.String({
+            pattern: "^\\d+(\\.\\d+)?%$",
+            description: 'Image width as percentage (e.g., "90%") relative to widthRelativeTo (defaults to content width)'
+          })
+        ],
+        {
+          description: 'Image width in pixels (number) or as percentage string (e.g., "90%")',
+          default: "100%"
+        }
+      )
+    ),
+    height: Type6.Optional(
+      Type6.Union(
+        [
+          Type6.Number({
+            minimum: 1,
+            description: "Image height in pixels"
+          }),
+          Type6.String({
+            pattern: "^\\d+(\\.\\d+)?%$",
+            description: 'Image height as percentage (e.g., "90%") relative to heightRelativeTo (defaults to content height)'
+          })
+        ],
+        {
+          description: 'Image height in pixels (number) or as percentage string (e.g., "90%")'
+        }
+      )
+    ),
+    widthRelativeTo: Type6.Optional(
+      Type6.Union([Type6.Literal("content"), Type6.Literal("page")], {
+        description: "Reference for width percentages: content (page width minus margins) or page (full page width)",
+        default: "content"
+      })
+    ),
+    heightRelativeTo: Type6.Optional(
+      Type6.Union([Type6.Literal("content"), Type6.Literal("page")], {
+        description: "Reference for height percentages: content (page height minus margins) or page (full page height)",
+        default: "content"
+      })
+    ),
+    alignment: Type6.Optional(AlignmentSchema),
+    caption: Type6.Optional(
+      Type6.String({
+        description: "Image caption (supports rich text with **bold**, *italic*, ***both***)"
+      })
+    ),
+    spacing: Type6.Optional(SpacingSchema),
+    floating: Type6.Optional(FloatingPropertiesSchema),
+    keepNext: Type6.Optional(
+      Type6.Boolean({
+        description: "Keep paragraph with next paragraph on same page"
+      })
+    ),
+    keepLines: Type6.Optional(
+      Type6.Boolean({
+        description: "Keep all lines of paragraph together on same page"
+      })
+    )
+  },
+  {
+    description: "Image component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/statistic.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var StatisticPropsSchema = Type7.Object(
+  {
+    number: Type7.String({
+      description: "Statistic number/value (required)"
+    }),
+    description: Type7.String({
+      description: "Statistic description (required)"
+    }),
+    unit: Type7.Optional(
+      Type7.String({
+        description: "Unit of measurement"
+      })
+    ),
+    format: Type7.Optional(
+      Type7.String({
+        description: "Number format pattern"
+      })
+    ),
+    trend: Type7.Optional(
+      Type7.Union([
+        Type7.Literal("up"),
+        Type7.Literal("down"),
+        Type7.Literal("neutral")
+      ])
+    ),
+    trendValue: Type7.Optional(Type7.Union([Type7.String(), Type7.Number()])),
+    alignment: Type7.Optional(AlignmentSchema),
+    spacing: Type7.Optional(SpacingSchema),
+    size: Type7.Optional(
+      Type7.Union([
+        Type7.Literal("small"),
+        Type7.Literal("medium"),
+        Type7.Literal("large")
+      ])
+    )
+  },
+  {
+    description: "Statistic component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/table.ts
+import { Type as Type8 } from "@sinclair/typebox";
+var CellContentSchema = Type8.Recursive(
+  (This) => Type8.Union([
+    Type8.String(),
+    Type8.Object(
+      {
+        name: Type8.String(),
+        props: Type8.Object({}, { additionalProperties: true }),
+        children: Type8.Optional(Type8.Array(This))
+      },
+      { additionalProperties: false }
+    )
+  ])
+);
+var HorizontalAlignmentSchema = Type8.Union(
+  [
+    Type8.Literal("left"),
+    Type8.Literal("center"),
+    Type8.Literal("right"),
+    Type8.Literal("justify")
+  ],
+  { description: "Horizontal text alignment" }
+);
+var VerticalAlignmentSchema = Type8.Union(
+  [Type8.Literal("top"), Type8.Literal("middle"), Type8.Literal("bottom")],
+  { description: "Vertical cell alignment" }
+);
+var FontConfigSchema = Type8.Object(
+  {
+    family: Type8.Optional(Type8.String({ description: "Font family name" })),
+    size: Type8.Optional(
+      Type8.Number({ minimum: 0, description: "Font size in points" })
+    ),
+    bold: Type8.Optional(Type8.Boolean({ description: "Bold text" })),
+    fontWeight: Type8.Optional(
+      Type8.Integer({
+        minimum: 100,
+        maximum: 900,
+        description: "Per-cell weight (100\u2013900). Overrides `bold` when set."
+      })
+    ),
+    italic: Type8.Optional(Type8.Boolean({ description: "Italic text" })),
+    underline: Type8.Optional(Type8.Boolean({ description: "Underlined text" }))
+  },
+  { additionalProperties: false }
+);
+var BorderColorSchema = Type8.Union([
+  Type8.String({ description: "Border color for all sides (hex without #)" }),
+  Type8.Object(
+    {
+      bottom: Type8.Optional(
+        Type8.String({ description: "Bottom border color (hex without #)" })
+      ),
+      top: Type8.Optional(
+        Type8.String({ description: "Top border color (hex without #)" })
+      ),
+      right: Type8.Optional(
+        Type8.String({ description: "Right border color (hex without #)" })
+      ),
+      left: Type8.Optional(
+        Type8.String({ description: "Left border color (hex without #)" })
+      )
+    },
+    { additionalProperties: false }
+  )
+]);
+var BorderSizeSchema = Type8.Union([
+  Type8.Number({
+    minimum: 0,
+    description: "Border size for all sides in points"
+  }),
+  Type8.Object(
+    {
+      bottom: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Bottom border size in points" })
+      ),
+      top: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Top border size in points" })
+      ),
+      right: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Right border size in points" })
+      ),
+      left: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Left border size in points" })
+      )
+    },
+    { additionalProperties: false }
+  )
+]);
+var HideBordersSchema = Type8.Union([
+  Type8.Boolean({
+    description: "Hide all borders when true"
+  }),
+  Type8.Object(
+    {
+      bottom: Type8.Optional(
+        Type8.Boolean({ description: "Hide bottom border" })
+      ),
+      top: Type8.Optional(Type8.Boolean({ description: "Hide top border" })),
+      right: Type8.Optional(Type8.Boolean({ description: "Hide right border" })),
+      left: Type8.Optional(Type8.Boolean({ description: "Hide left border" })),
+      insideHorizontal: Type8.Optional(
+        Type8.Boolean({ description: "Hide horizontal borders between rows" })
+      ),
+      insideVertical: Type8.Optional(
+        Type8.Boolean({ description: "Hide vertical borders between columns" })
+      )
+    },
+    {
+      description: "Selectively hide specific borders",
+      additionalProperties: false
+    }
+  )
+]);
+var PaddingSchema = Type8.Union([
+  Type8.Number({ minimum: 0, description: "Padding for all sides in points" }),
+  Type8.Object(
+    {
+      bottom: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Bottom padding in points" })
+      ),
+      top: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Top padding in points" })
+      ),
+      right: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Right padding in points" })
+      ),
+      left: Type8.Optional(
+        Type8.Number({ minimum: 0, description: "Left padding in points" })
+      )
+    },
+    { additionalProperties: false }
+  )
+]);
+var CellDefaultsSchema = Type8.Object(
+  {
+    color: Type8.Optional(HexColorSchema),
+    backgroundColor: Type8.Optional(HexColorOrTransparentSchema),
+    horizontalAlignment: Type8.Optional(HorizontalAlignmentSchema),
+    verticalAlignment: Type8.Optional(VerticalAlignmentSchema),
+    font: Type8.Optional(FontConfigSchema),
+    borderColor: Type8.Optional(BorderColorSchema),
+    borderSize: Type8.Optional(BorderSizeSchema),
+    padding: Type8.Optional(PaddingSchema),
+    height: Type8.Optional(
+      Type8.Number({ minimum: 0, description: "Cell height in points" })
+    )
+  },
+  { additionalProperties: false }
+);
+function createTablePropsSchema(componentRef) {
+  const cellContent = Type8.Union([Type8.String(), componentRef]);
+  const cellFields = {
+    color: Type8.Optional(HexColorSchema),
+    backgroundColor: Type8.Optional(HexColorOrTransparentSchema),
+    horizontalAlignment: Type8.Optional(HorizontalAlignmentSchema),
+    verticalAlignment: Type8.Optional(VerticalAlignmentSchema),
+    font: Type8.Optional(FontConfigSchema),
+    borderColor: Type8.Optional(BorderColorSchema),
+    borderSize: Type8.Optional(BorderSizeSchema),
+    padding: Type8.Optional(PaddingSchema),
+    height: Type8.Optional(
+      Type8.Number({ minimum: 0, description: "Cell height in points" })
+    ),
+    comment: Type8.Optional(CommentSchema),
+    revision: Type8.Optional(RevisionSchema)
+  };
+  const headerSchema = Type8.Object(
+    {
+      ...cellFields,
+      content: Type8.Optional(cellContent)
+    },
+    { additionalProperties: false }
+  );
+  const cellSchema = Type8.Object(
+    {
+      ...cellFields,
+      content: Type8.Optional(cellContent)
+    },
+    { additionalProperties: false }
+  );
+  const columnSchema = Type8.Object(
+    {
+      width: Type8.Optional(
+        Type8.Union([
+          Type8.Number({
+            minimum: 0,
+            description: "Column width in points. When set on some columns, remaining columns will automatically share the leftover table space equally. Leave undefined to distribute space evenly among unspecified columns."
+          }),
+          Type8.String({
+            pattern: "^\\d+(\\.\\d+)?%$",
+            description: 'Column width as percentage of available width (e.g., "40%")'
+          })
+        ])
+      ),
+      cellDefaults: Type8.Optional(CellDefaultsSchema),
+      header: Type8.Optional(headerSchema),
+      cells: Type8.Optional(Type8.Array(cellSchema))
+    },
+    { additionalProperties: false }
+  );
+  return Type8.Object(
+    {
+      borderColor: Type8.Optional(BorderColorSchema),
+      borderSize: Type8.Optional(BorderSizeSchema),
+      hideBorders: Type8.Optional(HideBordersSchema),
+      cellDefaults: Type8.Optional(CellDefaultsSchema),
+      headerCellDefaults: Type8.Optional(CellDefaultsSchema),
+      width: Type8.Optional(
+        Type8.Number({
+          minimum: 0,
+          maximum: 100,
+          description: "Table width in percentage (0-100)"
+        })
+      ),
+      columns: Type8.Array(columnSchema, {
+        description: "Table columns with headers and cells",
+        minItems: 1
+      }),
+      rows: Type8.Optional(
+        Type8.Array(
+          Type8.Object(
+            {
+              revision: Type8.Optional(RevisionMarkSchema),
+              cantSplit: Type8.Optional(
+                Type8.Boolean({
+                  description: "Keep this row on one page"
+                })
+              ),
+              tableHeader: Type8.Optional(
+                Type8.Boolean({
+                  description: "Repeat this row as a header on each page"
+                })
+              )
+            },
+            { additionalProperties: false }
+          ),
+          {
+            description: "Row-parallel properties, indexed like `columns[].cells`. The model is column-major, so anything that belongs to a whole row lives here."
+          }
+        )
+      ),
+      keepInOnePage: Type8.Optional(
+        Type8.Boolean({
+          description: "Keep table rows together on the same page by setting keepNext on all paragraphs"
+        })
+      ),
+      keepNext: Type8.Optional(
+        Type8.Boolean({
+          description: "Set keepNext on the last row to keep it connected to the next element. Works independently of keepInOnePage. Defaults to false."
+        })
+      ),
+      repeatHeaderOnPageBreak: Type8.Optional(
+        Type8.Boolean({
+          description: "Repeat the header row on each page when the table spans multiple pages. Defaults to true.",
+          default: true
+        })
+      )
+    },
+    {
+      description: "Table component props with column-based structure",
+      additionalProperties: false
+    }
+  );
+}
+var TablePropsSchema = createTablePropsSchema(CellContentSchema);
+
+// src/schemas/components/section.ts
+import { Type as Type9 } from "@sinclair/typebox";
+var createSectionPropsSchema = (componentRef) => Type9.Object(
+  {
+    meta: Type9.Optional(
+      Type9.Object(
+        {
+          title: Type9.Optional(
+            Type9.String({
+              description: "Authoring label for this section, shown in editors and outlines. Never rendered \u2014 add a heading child for a visible title."
+            })
+          )
+        },
+        {
+          additionalProperties: false,
+          description: "Authoring metadata; has no effect on the document."
+        }
+      )
+    ),
+    header: Type9.Optional(
+      Type9.Union([
+        Type9.Array(componentRef || Type9.Any(), {
+          description: "Section header components"
+        }),
+        Type9.Literal("linkToPrevious", {
+          description: "Link header to previous section"
+        })
+      ])
+    ),
+    footer: Type9.Optional(
+      Type9.Union([
+        Type9.Array(componentRef || Type9.Any(), {
+          description: "Section footer components"
+        }),
+        Type9.Literal("linkToPrevious", {
+          description: "Link footer to previous section"
+        })
+      ])
+    ),
+    pageBreak: Type9.Optional(
+      Type9.Boolean({
+        description: "Insert page break before section",
+        default: true
+      })
+    ),
+    spacing: Type9.Optional(SpacingSchema),
+    page: Type9.Optional(
+      Type9.Object(
+        {
+          size: Type9.Optional(
+            Type9.Union([
+              Type9.Literal("A4"),
+              Type9.Literal("A3"),
+              Type9.Literal("LETTER"),
+              Type9.Literal("LEGAL"),
+              Type9.Object({
+                width: Type9.Number({ minimum: 0 }),
+                height: Type9.Number({ minimum: 0 })
+              })
+            ])
+          ),
+          margins: Type9.Optional(
+            Type9.Object(
+              {
+                top: Type9.Optional(Type9.Number({ minimum: 0 })),
+                bottom: Type9.Optional(Type9.Number({ minimum: 0 })),
+                left: Type9.Optional(Type9.Number({ minimum: 0 })),
+                right: Type9.Optional(Type9.Number({ minimum: 0 })),
+                header: Type9.Optional(Type9.Number({ minimum: 0 })),
+                footer: Type9.Optional(Type9.Number({ minimum: 0 })),
+                gutter: Type9.Optional(Type9.Number({ minimum: 0 }))
+              },
+              {
+                additionalProperties: false
+              }
+            )
+          )
+        },
+        {
+          description: "Page configuration override for this section (overrides theme page settings)",
+          additionalProperties: false
+        }
+      )
+    )
+  },
+  {
+    description: "Section component props",
+    additionalProperties: false
+  }
+);
+var SectionPropsSchema = createSectionPropsSchema();
+
+// src/schemas/components/columns.ts
+import { Type as Type10 } from "@sinclair/typebox";
+var ColumnDescriptorSchema = Type10.Object(
+  {
+    width: Type10.Optional(
+      Type10.Union([
+        Type10.Number({
+          minimum: 1,
+          description: "Column width in points"
+        }),
+        Type10.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Column width as percentage of available width (e.g., "30%")'
+        }),
+        Type10.Literal("auto", {
+          description: "Auto width: consume remaining space after fixed widths and gaps"
+        })
+      ])
+    ),
+    gap: Type10.Optional(
+      Type10.Union([
+        Type10.Number({
+          minimum: 0,
+          description: "Gap after this column in points"
+        }),
+        Type10.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Gap after this column as percentage of available width (e.g., "5%")'
+        })
+      ])
+    )
+  },
+  { additionalProperties: false }
+);
+var ColumnsPropsSchema = Type10.Object(
+  {
+    columns: Type10.Union([
+      Type10.Number({
+        minimum: 1,
+        description: "Number of equal-width columns (converter will normalize to array)"
+      }),
+      Type10.Array(ColumnDescriptorSchema, {
+        minItems: 1,
+        description: "List of columns in order; width and gap can be points, percentages, or auto width"
+      })
+    ]),
+    gap: Type10.Optional(
+      Type10.Union([
+        Type10.Number({
+          minimum: 0,
+          description: "Default gap applied after each column except the last (points)"
+        }),
+        Type10.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Default gap applied after each column except the last as percentage of available width (e.g., "5%")'
+        })
+      ])
+    )
+  },
+  {
+    description: "Columns component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/list.ts
+import { Type as Type11 } from "@sinclair/typebox";
+var LevelFormatSchema = Type11.Union(
+  [
+    Type11.Literal("decimal"),
+    Type11.Literal("upperRoman"),
+    Type11.Literal("lowerRoman"),
+    Type11.Literal("upperLetter"),
+    Type11.Literal("lowerLetter"),
+    Type11.Literal("bullet"),
+    Type11.Literal("ordinal"),
+    Type11.Literal("cardinalText"),
+    Type11.Literal("ordinalText"),
+    Type11.Literal("hex"),
+    Type11.Literal("chicago"),
+    Type11.Literal("ideographDigital"),
+    Type11.Literal("japaneseCounting"),
+    Type11.Literal("aiueo"),
+    Type11.Literal("iroha"),
+    Type11.Literal("decimalFullWidth"),
+    Type11.Literal("decimalHalfWidth"),
+    Type11.Literal("japaneseLegal"),
+    Type11.Literal("japaneseDigitalTenThousand"),
+    Type11.Literal("decimalEnclosedCircle"),
+    Type11.Literal("decimalFullWidth2"),
+    Type11.Literal("aiueoFullWidth"),
+    Type11.Literal("irohaFullWidth"),
+    Type11.Literal("decimalZero"),
+    Type11.Literal("ganada"),
+    Type11.Literal("chosung"),
+    Type11.Literal("decimalEnclosedFullstop"),
+    Type11.Literal("decimalEnclosedParen"),
+    Type11.Literal("decimalEnclosedCircleChinese"),
+    Type11.Literal("ideographEnclosedCircle"),
+    Type11.Literal("ideographTraditional"),
+    Type11.Literal("ideographZodiac"),
+    Type11.Literal("ideographZodiacTraditional"),
+    Type11.Literal("taiwaneseCounting"),
+    Type11.Literal("ideographLegalTraditional"),
+    Type11.Literal("taiwaneseCountingThousand"),
+    Type11.Literal("taiwaneseDigital"),
+    Type11.Literal("chineseCounting"),
+    Type11.Literal("chineseLegalSimplified"),
+    Type11.Literal("chineseCountingThousand"),
+    Type11.Literal("koreanDigital"),
+    Type11.Literal("koreanCounting"),
+    Type11.Literal("koreanLegal"),
+    Type11.Literal("koreanDigital2"),
+    Type11.Literal("vietnameseCounting"),
+    Type11.Literal("russianLower"),
+    Type11.Literal("russianUpper"),
+    Type11.Literal("none"),
+    Type11.Literal("numberInDash"),
+    Type11.Literal("hebrew1"),
+    Type11.Literal("hebrew2"),
+    Type11.Literal("arabicAlpha"),
+    Type11.Literal("arabicAbjad"),
+    Type11.Literal("hindiVowels"),
+    Type11.Literal("hindiConsonants"),
+    Type11.Literal("hindiNumbers"),
+    Type11.Literal("hindiCounting"),
+    Type11.Literal("thaiLetters"),
+    Type11.Literal("thaiNumbers"),
+    Type11.Literal("thaiCounting")
+  ],
+  {
+    description: "Number or bullet format for list levels"
+  }
+);
+var ListMarkerFontSchema = Type11.Object(
+  {
+    family: Type11.Optional(Type11.String({ description: "Font family name" })),
+    size: Type11.Optional(
+      Type11.Number({ minimum: 1, description: "Marker size in points" })
+    ),
+    color: Type11.Optional(HexColorSchema),
+    bold: Type11.Optional(Type11.Boolean({ description: "Bold marker" })),
+    italic: Type11.Optional(Type11.Boolean({ description: "Italic marker" })),
+    underline: Type11.Optional(
+      Type11.Boolean({ description: "Underlined marker" })
+    )
+  },
+  {
+    description: "Styling for the number/bullet glyph only. The list text is unaffected.",
+    additionalProperties: false
+  }
+);
+var ListLevelPropsSchema = Type11.Object(
+  {
+    level: Type11.Number({
+      minimum: 0,
+      maximum: 8,
+      description: "Nesting level (0 = root, 1 = first sublevel, etc.)"
+    }),
+    format: Type11.Optional(LevelFormatSchema),
+    text: Type11.Optional(
+      Type11.String({
+        description: 'Number format string (e.g., "%1." for "1.", "%1)" for "1)", custom bullet character for bullet format)'
+      })
+    ),
+    alignment: Type11.Optional(
+      Type11.Union(
+        [
+          Type11.Literal("start"),
+          Type11.Literal("end"),
+          Type11.Literal("left"),
+          Type11.Literal("right"),
+          Type11.Literal("center")
+        ],
+        {
+          description: "Alignment of the numbering/bullet"
+        }
+      )
+    ),
+    indent: Type11.Optional(IndentSchema),
+    start: Type11.Optional(
+      Type11.Number({
+        minimum: 1,
+        description: "Starting number for this level (default: 1)"
+      })
+    ),
+    font: Type11.Optional(ListMarkerFontSchema)
+  },
+  {
+    description: "Configuration for a single list level",
+    additionalProperties: false
+  }
+);
+var ListPropsSchema = Type11.Object(
+  {
+    items: Type11.Array(
+      Type11.Union([
+        Type11.String(),
+        Type11.Object(
+          {
+            text: Type11.String(),
+            level: Type11.Optional(
+              Type11.Number({
+                minimum: 0,
+                maximum: 8,
+                description: "Nesting level for this item"
+              })
+            ),
+            id: Type11.Optional(
+              Type11.String({
+                description: "Bookmark id for this item, targetable by internal links (#id) and cross-references ([@id])"
+              })
+            ),
+            revision: Type11.Optional(RevisionSchema)
+          },
+          { additionalProperties: false }
+        )
+      ]),
+      {
+        description: "List items (required)",
+        minItems: 1
+      }
+    ),
+    reference: Type11.Optional(
+      Type11.String({
+        description: "Unique reference ID for this numbering configuration (auto-generated if not provided)"
+      })
+    ),
+    levels: Type11.Optional(
+      Type11.Array(ListLevelPropsSchema, {
+        description: "Configuration for each nesting level",
+        minItems: 1,
+        maxItems: 9
+      })
+    ),
+    // Simplified options for common use cases (when levels not specified)
+    format: Type11.Optional(
+      Type11.Union(
+        [LevelFormatSchema, Type11.Literal("numbered"), Type11.Literal("none")],
+        {
+          description: "Format for level 0 (simplified option when levels not specified)"
+        }
+      )
+    ),
+    bullet: Type11.Optional(
+      Type11.String({
+        description: "Custom bullet character (simplified option when levels not specified)"
+      })
+    ),
+    start: Type11.Optional(
+      Type11.Number({
+        minimum: 1,
+        description: "Starting number for level 0. Applies whether or not `levels` is given; a `start` on the level itself wins."
+      })
+    ),
+    spacing: Type11.Optional(ListSpacingSchema),
+    alignment: Type11.Optional(JustifiedAlignmentSchema),
+    indent: Type11.Optional(
+      Type11.Union([Type11.Number({ minimum: 0 }), IndentSchema])
+    ),
+    // Anchored to the list as a whole: the range opens on the first rendered
+    // item and closes on the last.
+    comment: Type11.Optional(CommentSchema)
+  },
+  {
+    description: "List component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/component-defaults.ts
+var PER_INSTANCE_PROPS = [
+  "revision",
+  "comment",
+  "footnotes",
+  "endnotes"
+];
+var HeadingComponentDefaultsSchema = Type12.Partial(
+  Type12.Omit(HeadingPropsSchema, PER_INSTANCE_PROPS)
+);
+var ParagraphComponentDefaultsSchema = Type12.Partial(
+  Type12.Omit(ParagraphPropsSchema, PER_INSTANCE_PROPS)
+);
+var ImageComponentDefaultsSchema = Type12.Partial(ImagePropsSchema);
+var StatisticComponentDefaultsSchema = Type12.Partial(StatisticPropsSchema);
+var TableComponentDefaultsSchema = Type12.Partial(
+  Type12.Omit(TablePropsSchema, ["rows"])
+);
+var SectionComponentDefaultsSchema = Type12.Partial(SectionPropsSchema);
+var ColumnsComponentDefaultsSchema = Type12.Partial(ColumnsPropsSchema);
+var ListComponentDefaultsSchema = Type12.Partial(
+  Type12.Omit(ListPropsSchema, PER_INSTANCE_PROPS)
+);
+var ComponentDefaultsSchema = Type12.Object(
+  {
+    heading: Type12.Optional(HeadingComponentDefaultsSchema),
+    paragraph: Type12.Optional(ParagraphComponentDefaultsSchema),
+    image: Type12.Optional(ImageComponentDefaultsSchema),
+    statistic: Type12.Optional(StatisticComponentDefaultsSchema),
+    table: Type12.Optional(TableComponentDefaultsSchema),
+    section: Type12.Optional(SectionComponentDefaultsSchema),
+    columns: Type12.Optional(ColumnsComponentDefaultsSchema),
+    list: Type12.Optional(ListComponentDefaultsSchema)
+  },
+  { additionalProperties: true }
+  // TODO: add a way to add strict custom component defaults when the plugin/registry paradigm will be implemented
+);
+
+export {
+  RevisionSegmentSchema,
+  RevisionSchema,
+  RevisionMarkSchema,
+  CommentReplySchema,
+  CommentSchema,
+  HeadingPropsSchema,
+  NoteSchema,
+  FootnotesSchema,
+  EndnotesSchema,
+  ParagraphPropsSchema,
+  ImagePropsSchema,
+  StatisticPropsSchema,
+  createTablePropsSchema,
+  TablePropsSchema,
+  createSectionPropsSchema,
+  SectionPropsSchema,
+  ColumnsPropsSchema,
+  LevelFormatSchema,
+  ListMarkerFontSchema,
+  ListLevelPropsSchema,
+  ListPropsSchema,
+  PER_INSTANCE_PROPS,
+  HeadingComponentDefaultsSchema,
+  ParagraphComponentDefaultsSchema,
+  ImageComponentDefaultsSchema,
+  StatisticComponentDefaultsSchema,
+  TableComponentDefaultsSchema,
+  SectionComponentDefaultsSchema,
+  ColumnsComponentDefaultsSchema,
+  ListComponentDefaultsSchema,
+  ComponentDefaultsSchema
+};
+//# sourceMappingURL=chunk-OP5PCDNN.js.map