@json-to-office/shared-docx 0.7.0 → 0.8.0

package/dist/chunk-F5IGGVWN.js

@@ -0,0 +1,1339 @@
+import {
+  FontDefinitionSchema,
+  HexColorOrTransparentSchema,
+  HexColorSchema
+} from "./chunk-JOXJOD2C.js";
+
+// src/schemas/component-defaults.ts
+import { Type as Type10 } from "@sinclair/typebox";
+
+// src/schemas/components/heading.ts
+import { Type as Type2 } from "@sinclair/typebox";
+
+// src/schemas/components/common.ts
+import { Type } from "@sinclair/typebox";
+var AlignmentSchema = Type.Union(
+  [Type.Literal("left"), Type.Literal("center"), Type.Literal("right")],
+  { description: "Text alignment options" }
+);
+var JustifiedAlignmentSchema = Type.Union(
+  [
+    Type.Literal("left"),
+    Type.Literal("center"),
+    Type.Literal("right"),
+    Type.Literal("justify")
+  ],
+  { description: "Text alignment options including justify" }
+);
+var HeadingLevelSchema = Type.Union(
+  [
+    Type.Literal(1),
+    Type.Literal(2),
+    Type.Literal(3),
+    Type.Literal(4),
+    Type.Literal(5),
+    Type.Literal(6)
+  ],
+  { description: "Heading level (1-6)" }
+);
+var SpacingSchema = Type.Object(
+  {
+    before: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Spacing before element in points"
+      })
+    ),
+    after: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Spacing after element in points"
+      })
+    )
+  },
+  {
+    description: "Spacing configuration",
+    additionalProperties: false
+  }
+);
+var ListSpacingSchema = Type.Object(
+  {
+    before: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Spacing before list in points"
+      })
+    ),
+    after: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Spacing after list in points"
+      })
+    ),
+    item: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Spacing between list items in points"
+      })
+    )
+  },
+  {
+    description: "List spacing configuration with item spacing",
+    additionalProperties: false
+  }
+);
+var MarginsSchema = Type.Object(
+  {
+    top: Type.Optional(Type.Number({ minimum: 0 })),
+    bottom: Type.Optional(Type.Number({ minimum: 0 })),
+    left: Type.Optional(Type.Number({ minimum: 0 })),
+    right: Type.Optional(Type.Number({ minimum: 0 }))
+  },
+  { description: "Margin configuration" }
+);
+var BorderSchema = Type.Object(
+  {
+    style: Type.Optional(
+      Type.Union([
+        Type.Literal("solid"),
+        Type.Literal("dashed"),
+        Type.Literal("dotted"),
+        Type.Literal("double"),
+        Type.Literal("none")
+      ])
+    ),
+    width: Type.Optional(Type.Number({ minimum: 0 })),
+    color: Type.Optional(HexColorSchema)
+  },
+  { description: "Border configuration" }
+);
+var LineSpacingSchema = Type.Object(
+  {
+    type: Type.Union([
+      Type.Literal("single"),
+      Type.Literal("atLeast"),
+      Type.Literal("exactly"),
+      Type.Literal("double"),
+      Type.Literal("multiple")
+    ]),
+    value: Type.Optional(Type.Number({ minimum: 0 }))
+  },
+  { description: "Line spacing configuration" }
+);
+var IndentSchema = Type.Object(
+  {
+    left: Type.Optional(Type.Number({ minimum: 0 })),
+    hanging: Type.Optional(Type.Number({ minimum: 0 }))
+  },
+  { description: "Indentation configuration" }
+);
+var HorizontalPositionRelativeFromSchema = Type.Union(
+  [
+    Type.Literal("character"),
+    Type.Literal("column"),
+    Type.Literal("margin"),
+    Type.Literal("page"),
+    Type.Literal("text")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Horizontal position relative to"
+  }
+);
+var VerticalPositionRelativeFromSchema = Type.Union(
+  [
+    Type.Literal("margin"),
+    Type.Literal("page"),
+    Type.Literal("paragraph"),
+    Type.Literal("line"),
+    Type.Literal("text")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Vertical position relative to"
+  }
+);
+var HorizontalPositionAlignSchema = Type.Union(
+  [
+    Type.Literal("left"),
+    Type.Literal("center"),
+    Type.Literal("right"),
+    Type.Literal("inside"),
+    Type.Literal("outside")
+  ],
+  {
+    description: "Horizontal alignment"
+  }
+);
+var VerticalPositionAlignSchema = Type.Union(
+  [
+    Type.Literal("top"),
+    Type.Literal("center"),
+    Type.Literal("bottom"),
+    Type.Literal("inside"),
+    Type.Literal("outside")
+  ],
+  {
+    description: "Vertical alignment"
+  }
+);
+var TextWrappingTypeSchema = Type.Union(
+  [
+    Type.Literal("none"),
+    Type.Literal("square"),
+    Type.Literal("topAndBottom"),
+    Type.Literal("around"),
+    // VML compatibility for text-box
+    Type.Literal("tight"),
+    // VML compatibility for text-box
+    Type.Literal("through")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Text wrapping type"
+  }
+);
+var TextWrappingSideSchema = Type.Union(
+  [
+    Type.Literal("bothSides"),
+    Type.Literal("left"),
+    Type.Literal("right"),
+    Type.Literal("largest")
+  ],
+  {
+    description: "Text wrapping side"
+  }
+);
+var FloatingPropertiesSchema = Type.Object(
+  {
+    horizontalPosition: Type.Optional(
+      Type.Object(
+        {
+          relative: Type.Optional(HorizontalPositionRelativeFromSchema),
+          align: Type.Optional(HorizontalPositionAlignSchema),
+          offset: Type.Optional(
+            Type.Union([
+              Type.Number({
+                description: "Horizontal offset in twips (1/20 of a point)"
+              }),
+              Type.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)"
+        }
+      )
+    ),
+    verticalPosition: Type.Optional(
+      Type.Object(
+        {
+          relative: Type.Optional(VerticalPositionRelativeFromSchema),
+          align: Type.Optional(VerticalPositionAlignSchema),
+          offset: Type.Optional(
+            Type.Union([
+              Type.Number({
+                description: "Vertical offset in twips (1/20 of a point)"
+              }),
+              Type.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)"
+        }
+      )
+    ),
+    wrap: Type.Optional(
+      Type.Object(
+        {
+          type: TextWrappingTypeSchema,
+          side: Type.Optional(TextWrappingSideSchema),
+          margins: Type.Optional(
+            Type.Object(
+              {
+                top: Type.Optional(
+                  Type.Union([
+                    Type.Number({ description: "Top margin in twips" }),
+                    Type.String({
+                      pattern: "^\\d+(\\.\\d+)?%$",
+                      description: "Top margin as percentage of page height"
+                    })
+                  ])
+                ),
+                bottom: Type.Optional(
+                  Type.Union([
+                    Type.Number({ description: "Bottom margin in twips" }),
+                    Type.String({
+                      pattern: "^\\d+(\\.\\d+)?%$",
+                      description: "Bottom margin as percentage of page height"
+                    })
+                  ])
+                ),
+                left: Type.Optional(
+                  Type.Union([
+                    Type.Number({ description: "Left margin in twips" }),
+                    Type.String({
+                      pattern: "^\\d+(\\.\\d+)?%$",
+                      description: "Left margin as percentage of page width"
+                    })
+                  ])
+                ),
+                right: Type.Optional(
+                  Type.Union([
+                    Type.Number({ description: "Right margin in twips" }),
+                    Type.String({
+                      pattern: "^\\d+(\\.\\d+)?%$",
+                      description: "Right margin as percentage of page width"
+                    })
+                  ])
+                )
+              },
+              {
+                description: "Distance from text margins"
+              }
+            )
+          )
+        },
+        {
+          description: "Text wrapping configuration"
+        }
+      )
+    ),
+    allowOverlap: Type.Optional(
+      Type.Boolean({
+        description: "Allow element to overlap with other elements"
+      })
+    ),
+    behindDocument: Type.Optional(
+      Type.Boolean({
+        description: "Place element behind document text"
+      })
+    ),
+    lockAnchor: Type.Optional(
+      Type.Boolean({
+        description: "Lock the anchor position"
+      })
+    ),
+    layoutInCell: Type.Optional(
+      Type.Boolean({
+        description: "Layout element within table cell"
+      })
+    ),
+    zIndex: Type.Optional(
+      Type.Number({
+        minimum: 0,
+        description: "Z-order for overlapping elements (must be non-negative)"
+      })
+    ),
+    rotation: Type.Optional(
+      Type.Number({
+        description: "Rotation angle in degrees"
+      })
+    ),
+    visibility: Type.Optional(
+      Type.Union([Type.Literal("hidden"), Type.Literal("inherit")], {
+        description: "Visibility of the floating element"
+      })
+    )
+  },
+  {
+    description: "Floating element properties"
+  }
+);
+var NumberingSchema = Type.Object(
+  {
+    start: Type.Optional(Type.Number({ minimum: 1 })),
+    style: Type.Optional(
+      Type.Union([
+        Type.Literal("decimal"),
+        Type.Literal("lowerLetter"),
+        Type.Literal("upperLetter"),
+        Type.Literal("lowerRoman"),
+        Type.Literal("upperRoman")
+      ])
+    ),
+    separator: Type.Optional(Type.String())
+  },
+  { description: "Numbering configuration for lists" }
+);
+var BaseComponentFields = {};
+var BaseComponentPropsSchema = Type.Object(BaseComponentFields, {
+  description: "Base component props",
+  additionalProperties: true
+});
+
+// src/schemas/components/heading.ts
+var HeadingPropsSchema = Type2.Object(
+  {
+    text: Type2.String({
+      description: "Heading text (required)"
+    }),
+    level: Type2.Optional(HeadingLevelSchema),
+    // Local font override: allows customizing family/size/color/bold/italic/underline
+    // without modifying theme styles. Supports partial overrides.
+    font: Type2.Optional(Type2.Partial(FontDefinitionSchema)),
+    alignment: Type2.Optional(JustifiedAlignmentSchema),
+    spacing: Type2.Optional(SpacingSchema),
+    lineSpacing: Type2.Optional(
+      Type2.Union([Type2.Number({ minimum: 0 }), LineSpacingSchema])
+    ),
+    pageBreak: Type2.Optional(
+      Type2.Boolean({
+        description: "Insert page break before heading"
+      })
+    ),
+    columnBreak: Type2.Optional(
+      Type2.Boolean({
+        description: "Insert column break before heading"
+      })
+    ),
+    numbering: Type2.Optional(
+      Type2.Boolean({
+        description: "Include in numbering"
+      })
+    ),
+    keepNext: Type2.Optional(
+      Type2.Boolean({
+        description: "Keep heading with next paragraph on same page"
+      })
+    ),
+    keepLines: Type2.Optional(
+      Type2.Boolean({
+        description: "Keep all lines of heading together on same page"
+      })
+    )
+  },
+  {
+    description: "Heading component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/paragraph.ts
+import { Type as Type3 } from "@sinclair/typebox";
+var FrameWrapTypeSchema = Type3.Union(
+  [
+    Type3.Literal("around"),
+    Type3.Literal("none"),
+    Type3.Literal("notBeside"),
+    Type3.Literal("through"),
+    Type3.Literal("tight"),
+    Type3.Literal("auto")
+  ],
+  {
+    description: "Frame text wrapping type"
+  }
+);
+var FrameAnchorTypeSchema = Type3.Union(
+  [Type3.Literal("margin"), Type3.Literal("page"), Type3.Literal("text")],
+  {
+    description: "Frame anchor type"
+  }
+);
+var FrameHorizontalAlignSchema = Type3.Union(
+  [
+    Type3.Literal("left"),
+    Type3.Literal("center"),
+    Type3.Literal("right"),
+    Type3.Literal("inside"),
+    Type3.Literal("outside")
+  ],
+  {
+    description: "Frame horizontal alignment"
+  }
+);
+var FrameVerticalAlignSchema = Type3.Union(
+  [
+    Type3.Literal("top"),
+    Type3.Literal("center"),
+    Type3.Literal("bottom"),
+    Type3.Literal("inside"),
+    Type3.Literal("outside")
+  ],
+  {
+    description: "Frame vertical alignment"
+  }
+);
+var FloatingFramePropertiesSchema = Type3.Object(
+  {
+    horizontalPosition: Type3.Optional(
+      Type3.Object(
+        {
+          relative: Type3.Optional(FrameAnchorTypeSchema),
+          align: Type3.Optional(FrameHorizontalAlignSchema),
+          offset: Type3.Optional(
+            Type3.Union([
+              Type3.Number({
+                description: "Horizontal offset in twips (1/20 of a point)"
+              }),
+              Type3.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)"
+        }
+      )
+    ),
+    verticalPosition: Type3.Optional(
+      Type3.Object(
+        {
+          relative: Type3.Optional(FrameAnchorTypeSchema),
+          align: Type3.Optional(FrameVerticalAlignSchema),
+          offset: Type3.Optional(
+            Type3.Union([
+              Type3.Number({
+                description: "Vertical offset in twips (1/20 of a point)"
+              }),
+              Type3.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)"
+        }
+      )
+    ),
+    wrap: Type3.Optional(
+      Type3.Object(
+        {
+          type: FrameWrapTypeSchema
+        },
+        {
+          description: "Text wrapping configuration"
+        }
+      )
+    ),
+    lockAnchor: Type3.Optional(
+      Type3.Boolean({
+        description: "Lock the anchor position"
+      })
+    ),
+    width: Type3.Optional(
+      Type3.Number({
+        minimum: 1,
+        description: "Frame width in twips (DXA units)"
+      })
+    ),
+    height: Type3.Optional(
+      Type3.Number({
+        minimum: 1,
+        description: "Frame height in twips (DXA units)"
+      })
+    )
+  },
+  {
+    description: "Floating text frame properties"
+  }
+);
+var AlignmentSchema2 = Type3.Union(
+  [
+    Type3.Literal("left"),
+    Type3.Literal("center"),
+    Type3.Literal("right"),
+    Type3.Literal("justify")
+  ],
+  {
+    description: "Paragraph text alignment"
+  }
+);
+var ParagraphPropsSchema = Type3.Object(
+  {
+    text: Type3.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: Type3.Optional(Type3.Partial(FontDefinitionSchema)),
+    // Optional reference to a named style from theme.styles (e.g., 'heading1', 'normal')
+    themeStyle: Type3.Optional(Type3.String()),
+    // Rich-text decoration color for bold segments (kept as top-level behavior option)
+    boldColor: Type3.Optional(Type3.String()),
+    // Paragraph spacing (in points) — limited paragraph-level option allowed
+    spacing: Type3.Optional(SpacingSchema),
+    // Paragraph alignment (moved from font to config level)
+    alignment: Type3.Optional(AlignmentSchema2),
+    pageBreak: Type3.Optional(
+      Type3.Boolean({
+        description: "Insert page break before paragraph"
+      })
+    ),
+    columnBreak: Type3.Optional(
+      Type3.Boolean({
+        description: "Insert column break before paragraph"
+      })
+    ),
+    floating: Type3.Optional(FloatingFramePropertiesSchema),
+    keepNext: Type3.Optional(
+      Type3.Boolean({
+        description: "Keep paragraph with next paragraph on same page"
+      })
+    ),
+    keepLines: Type3.Optional(
+      Type3.Boolean({
+        description: "Keep all lines of paragraph together on same page"
+      })
+    ),
+    id: Type3.Optional(
+      Type3.String({
+        description: "Unique identifier for internal linking (bookmark anchor)"
+      })
+    )
+  },
+  {
+    description: "Paragraph component props (font nested for theme consistency; no flat font properties)",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/image.ts
+import { Type as Type4 } from "@sinclair/typebox";
+var ImagePropsSchema = Type4.Object(
+  {
+    path: Type4.Optional(
+      Type4.String({
+        description: "Image source URL or file path (mutually exclusive with base64)"
+      })
+    ),
+    base64: Type4.Optional(
+      Type4.String({
+        description: 'Base64-encoded image data in data URI format (e.g., "data:image/png;base64,iVBORw0KGgo...") (mutually exclusive with path)'
+      })
+    ),
+    alt: Type4.Optional(
+      Type4.String({
+        description: "Alternative text for accessibility"
+      })
+    ),
+    width: Type4.Optional(
+      Type4.Union(
+        [
+          Type4.Number({
+            minimum: 1,
+            description: "Image width in pixels"
+          }),
+          Type4.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: Type4.Optional(
+      Type4.Union(
+        [
+          Type4.Number({
+            minimum: 1,
+            description: "Image height in pixels"
+          }),
+          Type4.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: Type4.Optional(
+      Type4.Union([Type4.Literal("content"), Type4.Literal("page")], {
+        description: "Reference for width percentages: content (page width minus margins) or page (full page width)",
+        default: "content"
+      })
+    ),
+    heightRelativeTo: Type4.Optional(
+      Type4.Union([Type4.Literal("content"), Type4.Literal("page")], {
+        description: "Reference for height percentages: content (page height minus margins) or page (full page height)",
+        default: "content"
+      })
+    ),
+    alignment: Type4.Optional(AlignmentSchema),
+    caption: Type4.Optional(
+      Type4.String({
+        description: "Image caption (supports rich text with **bold**, *italic*, ***both***)"
+      })
+    ),
+    spacing: Type4.Optional(SpacingSchema),
+    floating: Type4.Optional(FloatingPropertiesSchema),
+    keepNext: Type4.Optional(
+      Type4.Boolean({
+        description: "Keep paragraph with next paragraph on same page"
+      })
+    ),
+    keepLines: Type4.Optional(
+      Type4.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 Type5 } from "@sinclair/typebox";
+var StatisticPropsSchema = Type5.Object(
+  {
+    number: Type5.String({
+      description: "Statistic number/value (required)"
+    }),
+    description: Type5.String({
+      description: "Statistic description (required)"
+    }),
+    unit: Type5.Optional(
+      Type5.String({
+        description: "Unit of measurement"
+      })
+    ),
+    format: Type5.Optional(
+      Type5.String({
+        description: "Number format pattern"
+      })
+    ),
+    trend: Type5.Optional(
+      Type5.Union([
+        Type5.Literal("up"),
+        Type5.Literal("down"),
+        Type5.Literal("neutral")
+      ])
+    ),
+    trendValue: Type5.Optional(Type5.Union([Type5.String(), Type5.Number()])),
+    alignment: Type5.Optional(AlignmentSchema),
+    spacing: Type5.Optional(SpacingSchema),
+    size: Type5.Optional(
+      Type5.Union([
+        Type5.Literal("small"),
+        Type5.Literal("medium"),
+        Type5.Literal("large")
+      ])
+    )
+  },
+  {
+    description: "Statistic component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/table.ts
+import { Type as Type6 } from "@sinclair/typebox";
+var CellContentSchema = Type6.Recursive(
+  (This) => Type6.Union([
+    Type6.String(),
+    Type6.Object(
+      {
+        name: Type6.String(),
+        props: Type6.Object({}, { additionalProperties: true }),
+        children: Type6.Optional(Type6.Array(This))
+      },
+      { additionalProperties: false }
+    )
+  ])
+);
+var HorizontalAlignmentSchema = Type6.Union(
+  [
+    Type6.Literal("left"),
+    Type6.Literal("center"),
+    Type6.Literal("right"),
+    Type6.Literal("justify")
+  ],
+  { description: "Horizontal text alignment" }
+);
+var VerticalAlignmentSchema = Type6.Union(
+  [Type6.Literal("top"), Type6.Literal("middle"), Type6.Literal("bottom")],
+  { description: "Vertical cell alignment" }
+);
+var FontConfigSchema = Type6.Object({
+  family: Type6.Optional(Type6.String({ description: "Font family name" })),
+  size: Type6.Optional(
+    Type6.Number({ minimum: 0, description: "Font size in points" })
+  ),
+  bold: Type6.Optional(Type6.Boolean({ description: "Bold text" })),
+  italic: Type6.Optional(Type6.Boolean({ description: "Italic text" })),
+  underline: Type6.Optional(Type6.Boolean({ description: "Underlined text" }))
+});
+var BorderColorSchema = Type6.Union([
+  Type6.String({ description: "Border color for all sides (hex without #)" }),
+  Type6.Object({
+    bottom: Type6.Optional(
+      Type6.String({ description: "Bottom border color (hex without #)" })
+    ),
+    top: Type6.Optional(
+      Type6.String({ description: "Top border color (hex without #)" })
+    ),
+    right: Type6.Optional(
+      Type6.String({ description: "Right border color (hex without #)" })
+    ),
+    left: Type6.Optional(
+      Type6.String({ description: "Left border color (hex without #)" })
+    )
+  })
+]);
+var BorderSizeSchema = Type6.Union([
+  Type6.Number({
+    minimum: 0,
+    description: "Border size for all sides in points"
+  }),
+  Type6.Object({
+    bottom: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Bottom border size in points" })
+    ),
+    top: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Top border size in points" })
+    ),
+    right: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Right border size in points" })
+    ),
+    left: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Left border size in points" })
+    )
+  })
+]);
+var HideBordersSchema = Type6.Union([
+  Type6.Boolean({
+    description: "Hide all borders when true"
+  }),
+  Type6.Object(
+    {
+      bottom: Type6.Optional(
+        Type6.Boolean({ description: "Hide bottom border" })
+      ),
+      top: Type6.Optional(Type6.Boolean({ description: "Hide top border" })),
+      right: Type6.Optional(Type6.Boolean({ description: "Hide right border" })),
+      left: Type6.Optional(Type6.Boolean({ description: "Hide left border" })),
+      insideHorizontal: Type6.Optional(
+        Type6.Boolean({ description: "Hide horizontal borders between rows" })
+      ),
+      insideVertical: Type6.Optional(
+        Type6.Boolean({ description: "Hide vertical borders between columns" })
+      )
+    },
+    { description: "Selectively hide specific borders" }
+  )
+]);
+var PaddingSchema = Type6.Union([
+  Type6.Number({ minimum: 0, description: "Padding for all sides in points" }),
+  Type6.Object({
+    bottom: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Bottom padding in points" })
+    ),
+    top: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Top padding in points" })
+    ),
+    right: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Right padding in points" })
+    ),
+    left: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Left padding in points" })
+    )
+  })
+]);
+var CellDefaultsSchema = Type6.Object({
+  color: Type6.Optional(HexColorSchema),
+  backgroundColor: Type6.Optional(HexColorOrTransparentSchema),
+  horizontalAlignment: Type6.Optional(HorizontalAlignmentSchema),
+  verticalAlignment: Type6.Optional(VerticalAlignmentSchema),
+  font: Type6.Optional(FontConfigSchema),
+  borderColor: Type6.Optional(BorderColorSchema),
+  borderSize: Type6.Optional(BorderSizeSchema),
+  padding: Type6.Optional(PaddingSchema),
+  height: Type6.Optional(
+    Type6.Number({ minimum: 0, description: "Cell height in points" })
+  )
+});
+function createTablePropsSchema(componentRef) {
+  const cellContent = Type6.Union([Type6.String(), componentRef]);
+  const cellFields = {
+    color: Type6.Optional(HexColorSchema),
+    backgroundColor: Type6.Optional(HexColorOrTransparentSchema),
+    horizontalAlignment: Type6.Optional(HorizontalAlignmentSchema),
+    verticalAlignment: Type6.Optional(VerticalAlignmentSchema),
+    font: Type6.Optional(FontConfigSchema),
+    borderColor: Type6.Optional(BorderColorSchema),
+    borderSize: Type6.Optional(BorderSizeSchema),
+    padding: Type6.Optional(PaddingSchema),
+    height: Type6.Optional(
+      Type6.Number({ minimum: 0, description: "Cell height in points" })
+    )
+  };
+  const headerSchema = Type6.Object({
+    ...cellFields,
+    content: Type6.Optional(cellContent)
+  });
+  const cellSchema = Type6.Object({
+    ...cellFields,
+    content: Type6.Optional(cellContent)
+  });
+  const columnSchema = Type6.Object({
+    width: Type6.Optional(
+      Type6.Union([
+        Type6.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."
+        }),
+        Type6.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Column width as percentage of available width (e.g., "40%")'
+        })
+      ])
+    ),
+    cellDefaults: Type6.Optional(CellDefaultsSchema),
+    header: Type6.Optional(headerSchema),
+    cells: Type6.Optional(Type6.Array(cellSchema))
+  });
+  return Type6.Object(
+    {
+      borderColor: Type6.Optional(BorderColorSchema),
+      borderSize: Type6.Optional(BorderSizeSchema),
+      hideBorders: Type6.Optional(HideBordersSchema),
+      cellDefaults: Type6.Optional(CellDefaultsSchema),
+      headerCellDefaults: Type6.Optional(CellDefaultsSchema),
+      width: Type6.Optional(
+        Type6.Number({
+          minimum: 0,
+          maximum: 100,
+          description: "Table width in percentage (0-100)"
+        })
+      ),
+      columns: Type6.Array(columnSchema, {
+        description: "Table columns with headers and cells",
+        minItems: 1
+      }),
+      keepInOnePage: Type6.Optional(
+        Type6.Boolean({
+          description: "Keep table rows together on the same page by setting keepNext on all paragraphs"
+        })
+      ),
+      keepNext: Type6.Optional(
+        Type6.Boolean({
+          description: "Set keepNext on the last row to keep it connected to the next element. Works independently of keepInOnePage. Defaults to false."
+        })
+      ),
+      repeatHeaderOnPageBreak: Type6.Optional(
+        Type6.Boolean({
+          description: "Repeat the header row on each page when the table spans multiple pages. Defaults to false.",
+          default: true
+        })
+      )
+    },
+    {
+      description: "Table component props with column-based structure"
+    }
+  );
+}
+var TablePropsSchema = createTablePropsSchema(CellContentSchema);
+
+// src/schemas/components/section.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var createSectionPropsSchema = (moduleRef) => Type7.Object(
+  {
+    title: Type7.Optional(
+      Type7.String({
+        description: "Section title (optional)"
+      })
+    ),
+    level: Type7.Optional(
+      Type7.Number({
+        minimum: 1,
+        maximum: 9,
+        description: "Heading level for section title (1-9)",
+        default: 1
+      })
+    ),
+    header: Type7.Optional(
+      Type7.Union([
+        Type7.Array(moduleRef || Type7.Any(), {
+          description: "Section header modules"
+        }),
+        Type7.Literal("linkToPrevious", {
+          description: "Link header to previous section"
+        })
+      ])
+    ),
+    footer: Type7.Optional(
+      Type7.Union([
+        Type7.Array(moduleRef || Type7.Any(), {
+          description: "Section footer modules"
+        }),
+        Type7.Literal("linkToPrevious", {
+          description: "Link footer to previous section"
+        })
+      ])
+    ),
+    pageBreak: Type7.Optional(
+      Type7.Boolean({
+        description: "Insert page break before section",
+        default: true
+      })
+    ),
+    spacing: Type7.Optional(SpacingSchema),
+    page: Type7.Optional(
+      Type7.Object(
+        {
+          size: Type7.Optional(
+            Type7.Union([
+              Type7.Literal("A4"),
+              Type7.Literal("A3"),
+              Type7.Literal("LETTER"),
+              Type7.Literal("LEGAL"),
+              Type7.Object({
+                width: Type7.Number({ minimum: 0 }),
+                height: Type7.Number({ minimum: 0 })
+              })
+            ])
+          ),
+          margins: Type7.Optional(
+            Type7.Object(
+              {
+                top: Type7.Optional(Type7.Number({ minimum: 0 })),
+                bottom: Type7.Optional(Type7.Number({ minimum: 0 })),
+                left: Type7.Optional(Type7.Number({ minimum: 0 })),
+                right: Type7.Optional(Type7.Number({ minimum: 0 })),
+                header: Type7.Optional(Type7.Number({ minimum: 0 })),
+                footer: Type7.Optional(Type7.Number({ minimum: 0 })),
+                gutter: Type7.Optional(Type7.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 Type8 } from "@sinclair/typebox";
+var ColumnDescriptorSchema = Type8.Object(
+  {
+    width: Type8.Optional(
+      Type8.Union([
+        Type8.Number({
+          minimum: 1,
+          description: "Column width in points"
+        }),
+        Type8.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Column width as percentage of available width (e.g., "30%")'
+        }),
+        Type8.Literal("auto", {
+          description: "Auto width: consume remaining space after fixed widths and gaps"
+        })
+      ])
+    ),
+    gap: Type8.Optional(
+      Type8.Union([
+        Type8.Number({
+          minimum: 0,
+          description: "Gap after this column in points"
+        }),
+        Type8.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Gap after this column as percentage of available width (e.g., "5%")'
+        })
+      ])
+    )
+  },
+  { additionalProperties: false }
+);
+var ColumnsPropsSchema = Type8.Object(
+  {
+    columns: Type8.Union([
+      Type8.Number({
+        minimum: 1,
+        description: "Number of equal-width columns (converter will normalize to array)"
+      }),
+      Type8.Array(ColumnDescriptorSchema, {
+        minItems: 1,
+        description: "List of columns in order; width and gap can be points, percentages, or auto width"
+      })
+    ]),
+    gap: Type8.Optional(
+      Type8.Union([
+        Type8.Number({
+          minimum: 0,
+          description: "Default gap applied after each column except the last (points)"
+        }),
+        Type8.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 Type9 } from "@sinclair/typebox";
+var LevelFormatSchema = Type9.Union(
+  [
+    Type9.Literal("decimal"),
+    Type9.Literal("upperRoman"),
+    Type9.Literal("lowerRoman"),
+    Type9.Literal("upperLetter"),
+    Type9.Literal("lowerLetter"),
+    Type9.Literal("bullet"),
+    Type9.Literal("ordinal"),
+    Type9.Literal("cardinalText"),
+    Type9.Literal("ordinalText"),
+    Type9.Literal("hex"),
+    Type9.Literal("chicago"),
+    Type9.Literal("ideographDigital"),
+    Type9.Literal("japaneseCounting"),
+    Type9.Literal("aiueo"),
+    Type9.Literal("iroha"),
+    Type9.Literal("decimalFullWidth"),
+    Type9.Literal("decimalHalfWidth"),
+    Type9.Literal("japaneseLegal"),
+    Type9.Literal("japaneseDigitalTenThousand"),
+    Type9.Literal("decimalEnclosedCircle"),
+    Type9.Literal("decimalFullWidth2"),
+    Type9.Literal("aiueoFullWidth"),
+    Type9.Literal("irohaFullWidth"),
+    Type9.Literal("decimalZero"),
+    Type9.Literal("ganada"),
+    Type9.Literal("chosung"),
+    Type9.Literal("decimalEnclosedFullstop"),
+    Type9.Literal("decimalEnclosedParen"),
+    Type9.Literal("decimalEnclosedCircleChinese"),
+    Type9.Literal("ideographEnclosedCircle"),
+    Type9.Literal("ideographTraditional"),
+    Type9.Literal("ideographZodiac"),
+    Type9.Literal("ideographZodiacTraditional"),
+    Type9.Literal("taiwaneseCounting"),
+    Type9.Literal("ideographLegalTraditional"),
+    Type9.Literal("taiwaneseCountingThousand"),
+    Type9.Literal("taiwaneseDigital"),
+    Type9.Literal("chineseCounting"),
+    Type9.Literal("chineseLegalSimplified"),
+    Type9.Literal("chineseCountingThousand"),
+    Type9.Literal("koreanDigital"),
+    Type9.Literal("koreanCounting"),
+    Type9.Literal("koreanLegal"),
+    Type9.Literal("koreanDigital2"),
+    Type9.Literal("vietnameseCounting"),
+    Type9.Literal("russianLower"),
+    Type9.Literal("russianUpper"),
+    Type9.Literal("none"),
+    Type9.Literal("numberInDash"),
+    Type9.Literal("hebrew1"),
+    Type9.Literal("hebrew2"),
+    Type9.Literal("arabicAlpha"),
+    Type9.Literal("arabicAbjad"),
+    Type9.Literal("hindiVowels"),
+    Type9.Literal("hindiConsonants"),
+    Type9.Literal("hindiNumbers"),
+    Type9.Literal("hindiCounting"),
+    Type9.Literal("thaiLetters"),
+    Type9.Literal("thaiNumbers"),
+    Type9.Literal("thaiCounting")
+  ],
+  {
+    description: "Number or bullet format for list levels"
+  }
+);
+var ListLevelPropsSchema = Type9.Object(
+  {
+    level: Type9.Number({
+      minimum: 0,
+      maximum: 8,
+      description: "Nesting level (0 = root, 1 = first sublevel, etc.)"
+    }),
+    format: Type9.Optional(LevelFormatSchema),
+    text: Type9.Optional(
+      Type9.String({
+        description: 'Number format string (e.g., "%1." for "1.", "%1)" for "1)", custom bullet character for bullet format)'
+      })
+    ),
+    alignment: Type9.Optional(
+      Type9.Union(
+        [
+          Type9.Literal("start"),
+          Type9.Literal("end"),
+          Type9.Literal("left"),
+          Type9.Literal("right"),
+          Type9.Literal("center")
+        ],
+        {
+          description: "Alignment of the numbering/bullet"
+        }
+      )
+    ),
+    indent: Type9.Optional(IndentSchema),
+    start: Type9.Optional(
+      Type9.Number({
+        minimum: 1,
+        description: "Starting number for this level (default: 1)"
+      })
+    )
+  },
+  {
+    description: "Configuration for a single list level"
+  }
+);
+var ListPropsSchema = Type9.Object(
+  {
+    items: Type9.Array(
+      Type9.Union([
+        Type9.String(),
+        Type9.Object({
+          text: Type9.String(),
+          level: Type9.Optional(
+            Type9.Number({
+              minimum: 0,
+              maximum: 8,
+              description: "Nesting level for this item"
+            })
+          )
+        })
+      ]),
+      {
+        description: "List items (required)",
+        minItems: 1
+      }
+    ),
+    reference: Type9.Optional(
+      Type9.String({
+        description: "Unique reference ID for this numbering configuration (auto-generated if not provided)"
+      })
+    ),
+    levels: Type9.Optional(
+      Type9.Array(ListLevelPropsSchema, {
+        description: "Configuration for each nesting level",
+        minItems: 1,
+        maxItems: 9
+      })
+    ),
+    // Simplified options for common use cases (when levels not specified)
+    format: Type9.Optional(
+      Type9.Union(
+        [LevelFormatSchema, Type9.Literal("numbered"), Type9.Literal("none")],
+        {
+          description: "Format for level 0 (simplified option when levels not specified)"
+        }
+      )
+    ),
+    bullet: Type9.Optional(
+      Type9.String({
+        description: "Custom bullet character (simplified option when levels not specified)"
+      })
+    ),
+    start: Type9.Optional(
+      Type9.Number({
+        minimum: 1,
+        description: "Starting number for level 0 (simplified option when levels not specified)"
+      })
+    ),
+    spacing: Type9.Optional(ListSpacingSchema),
+    alignment: Type9.Optional(JustifiedAlignmentSchema),
+    indent: Type9.Optional(
+      Type9.Union([Type9.Number({ minimum: 0 }), IndentSchema])
+    )
+  },
+  {
+    description: "List component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/component-defaults.ts
+var HeadingComponentDefaultsSchema = Type10.Partial(HeadingPropsSchema);
+var ParagraphComponentDefaultsSchema = Type10.Partial(ParagraphPropsSchema);
+var ImageComponentDefaultsSchema = Type10.Partial(ImagePropsSchema);
+var StatisticComponentDefaultsSchema = Type10.Partial(StatisticPropsSchema);
+var TableComponentDefaultsSchema = Type10.Partial(TablePropsSchema);
+var SectionComponentDefaultsSchema = Type10.Partial(SectionPropsSchema);
+var ColumnsComponentDefaultsSchema = Type10.Partial(ColumnsPropsSchema);
+var ListComponentDefaultsSchema = Type10.Partial(ListPropsSchema);
+var ComponentDefaultsSchema = Type10.Object(
+  {
+    heading: Type10.Optional(HeadingComponentDefaultsSchema),
+    paragraph: Type10.Optional(ParagraphComponentDefaultsSchema),
+    image: Type10.Optional(ImageComponentDefaultsSchema),
+    statistic: Type10.Optional(StatisticComponentDefaultsSchema),
+    table: Type10.Optional(TableComponentDefaultsSchema),
+    section: Type10.Optional(SectionComponentDefaultsSchema),
+    columns: Type10.Optional(ColumnsComponentDefaultsSchema),
+    list: Type10.Optional(ListComponentDefaultsSchema)
+  },
+  { additionalProperties: true }
+  // TODO: add a way to add strict custom component defaults when the plugin/registry paradigm will be implemented
+);
+
+export {
+  AlignmentSchema,
+  JustifiedAlignmentSchema,
+  HeadingLevelSchema,
+  SpacingSchema,
+  ListSpacingSchema,
+  MarginsSchema,
+  BorderSchema,
+  LineSpacingSchema,
+  IndentSchema,
+  HorizontalPositionRelativeFromSchema,
+  VerticalPositionRelativeFromSchema,
+  HorizontalPositionAlignSchema,
+  VerticalPositionAlignSchema,
+  TextWrappingTypeSchema,
+  TextWrappingSideSchema,
+  FloatingPropertiesSchema,
+  NumberingSchema,
+  BaseComponentFields,
+  BaseComponentPropsSchema,
+  HeadingPropsSchema,
+  ParagraphPropsSchema,
+  ImagePropsSchema,
+  StatisticPropsSchema,
+  createTablePropsSchema,
+  TablePropsSchema,
+  createSectionPropsSchema,
+  SectionPropsSchema,
+  ColumnsPropsSchema,
+  LevelFormatSchema,
+  ListLevelPropsSchema,
+  ListPropsSchema,
+  HeadingComponentDefaultsSchema,
+  ParagraphComponentDefaultsSchema,
+  ImageComponentDefaultsSchema,
+  StatisticComponentDefaultsSchema,
+  TableComponentDefaultsSchema,
+  SectionComponentDefaultsSchema,
+  ColumnsComponentDefaultsSchema,
+  ListComponentDefaultsSchema,
+  ComponentDefaultsSchema
+};
+//# sourceMappingURL=chunk-F5IGGVWN.js.map