@json-to-office/shared-docx 0.1.0

package/dist/chunk-5533WPL6.js

@@ -0,0 +1,1895 @@
+import {
+  FontDefinitionSchema,
+  HexColorSchema
+} from "./chunk-F5LVWDTY.js";
+
+// src/schemas/component-registry.ts
+import { Type as Type16 } from "@sinclair/typebox";
+
+// src/schemas/components/report.ts
+import { Type } from "@sinclair/typebox";
+var createReportPropsSchema = (_moduleRef) => Type.Object(
+  {
+    theme: Type.Optional(
+      Type.String({
+        description: 'Theme name to apply (default: "minimal")',
+        examples: ["corporate", "professional", "minimal"],
+        default: "minimal"
+      })
+    ),
+    metadata: Type.Optional(
+      Type.Object(
+        {
+          title: Type.Optional(
+            Type.String({
+              description: "Document title",
+              examples: ["Annual Report 2024", "Technical Documentation"]
+            })
+          ),
+          subtitle: Type.Optional(
+            Type.String({
+              description: "Document subtitle"
+            })
+          ),
+          description: Type.Optional(Type.String()),
+          author: Type.Optional(Type.String()),
+          company: Type.Optional(Type.String()),
+          date: Type.Optional(Type.String()),
+          created: Type.Optional(Type.String({ format: "date-time" })),
+          modified: Type.Optional(Type.String({ format: "date-time" })),
+          version: Type.Optional(Type.String()),
+          tags: Type.Optional(Type.Array(Type.String()))
+        },
+        {
+          description: "Document metadata (title, author, company, dates, etc.)",
+          additionalProperties: false
+        }
+      )
+    )
+  },
+  {
+    description: "Report component props",
+    additionalProperties: false
+  }
+);
+var ReportPropsSchema = createReportPropsSchema();
+
+// src/schemas/components/section.ts
+import { Type as Type3 } from "@sinclair/typebox";
+
+// src/schemas/components/common.ts
+import { Type as Type2 } from "@sinclair/typebox";
+var AlignmentSchema = Type2.Union(
+  [Type2.Literal("left"), Type2.Literal("center"), Type2.Literal("right")],
+  { description: "Text alignment options" }
+);
+var JustifiedAlignmentSchema = Type2.Union(
+  [
+    Type2.Literal("left"),
+    Type2.Literal("center"),
+    Type2.Literal("right"),
+    Type2.Literal("justify")
+  ],
+  { description: "Text alignment options including justify" }
+);
+var HeadingLevelSchema = Type2.Union(
+  [
+    Type2.Literal(1),
+    Type2.Literal(2),
+    Type2.Literal(3),
+    Type2.Literal(4),
+    Type2.Literal(5),
+    Type2.Literal(6)
+  ],
+  { description: "Heading level (1-6)" }
+);
+var SpacingSchema = Type2.Object(
+  {
+    before: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Spacing before element in points"
+      })
+    ),
+    after: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Spacing after element in points"
+      })
+    )
+  },
+  {
+    description: "Spacing configuration",
+    additionalProperties: false
+  }
+);
+var ListSpacingSchema = Type2.Object(
+  {
+    before: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Spacing before list in points"
+      })
+    ),
+    after: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Spacing after list in points"
+      })
+    ),
+    item: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Spacing between list items in points"
+      })
+    )
+  },
+  {
+    description: "List spacing configuration with item spacing",
+    additionalProperties: false
+  }
+);
+var MarginsSchema = Type2.Object(
+  {
+    top: Type2.Optional(Type2.Number({ minimum: 0 })),
+    bottom: Type2.Optional(Type2.Number({ minimum: 0 })),
+    left: Type2.Optional(Type2.Number({ minimum: 0 })),
+    right: Type2.Optional(Type2.Number({ minimum: 0 }))
+  },
+  { description: "Margin configuration" }
+);
+var BorderSchema = Type2.Object(
+  {
+    style: Type2.Optional(
+      Type2.Union([
+        Type2.Literal("solid"),
+        Type2.Literal("dashed"),
+        Type2.Literal("dotted"),
+        Type2.Literal("double"),
+        Type2.Literal("none")
+      ])
+    ),
+    width: Type2.Optional(Type2.Number({ minimum: 0 })),
+    color: Type2.Optional(HexColorSchema)
+  },
+  { description: "Border configuration" }
+);
+var LineSpacingSchema = Type2.Object(
+  {
+    type: Type2.Union([
+      Type2.Literal("single"),
+      Type2.Literal("atLeast"),
+      Type2.Literal("exactly"),
+      Type2.Literal("double"),
+      Type2.Literal("multiple")
+    ]),
+    value: Type2.Optional(Type2.Number({ minimum: 0 }))
+  },
+  { description: "Line spacing configuration" }
+);
+var IndentSchema = Type2.Object(
+  {
+    left: Type2.Optional(Type2.Number({ minimum: 0 })),
+    hanging: Type2.Optional(Type2.Number({ minimum: 0 }))
+  },
+  { description: "Indentation configuration" }
+);
+var HorizontalPositionRelativeFromSchema = Type2.Union(
+  [
+    Type2.Literal("character"),
+    Type2.Literal("column"),
+    Type2.Literal("margin"),
+    Type2.Literal("page"),
+    Type2.Literal("text")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Horizontal position relative to"
+  }
+);
+var VerticalPositionRelativeFromSchema = Type2.Union(
+  [
+    Type2.Literal("margin"),
+    Type2.Literal("page"),
+    Type2.Literal("paragraph"),
+    Type2.Literal("line"),
+    Type2.Literal("text")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Vertical position relative to"
+  }
+);
+var HorizontalPositionAlignSchema = Type2.Union(
+  [
+    Type2.Literal("left"),
+    Type2.Literal("center"),
+    Type2.Literal("right"),
+    Type2.Literal("inside"),
+    Type2.Literal("outside")
+  ],
+  {
+    description: "Horizontal alignment"
+  }
+);
+var VerticalPositionAlignSchema = Type2.Union(
+  [
+    Type2.Literal("top"),
+    Type2.Literal("center"),
+    Type2.Literal("bottom"),
+    Type2.Literal("inside"),
+    Type2.Literal("outside")
+  ],
+  {
+    description: "Vertical alignment"
+  }
+);
+var TextWrappingTypeSchema = Type2.Union(
+  [
+    Type2.Literal("none"),
+    Type2.Literal("square"),
+    Type2.Literal("topAndBottom"),
+    Type2.Literal("around"),
+    // VML compatibility for text-box
+    Type2.Literal("tight"),
+    // VML compatibility for text-box
+    Type2.Literal("through")
+    // VML compatibility for text-box
+  ],
+  {
+    description: "Text wrapping type"
+  }
+);
+var TextWrappingSideSchema = Type2.Union(
+  [
+    Type2.Literal("bothSides"),
+    Type2.Literal("left"),
+    Type2.Literal("right"),
+    Type2.Literal("largest")
+  ],
+  {
+    description: "Text wrapping side"
+  }
+);
+var FloatingPropertiesSchema = Type2.Object(
+  {
+    horizontalPosition: Type2.Optional(
+      Type2.Object(
+        {
+          relative: Type2.Optional(HorizontalPositionRelativeFromSchema),
+          align: Type2.Optional(HorizontalPositionAlignSchema),
+          offset: Type2.Optional(
+            Type2.Number({
+              description: "Horizontal offset in twips (1/20 of a point)"
+            })
+          )
+        },
+        {
+          description: "Horizontal positioning (use either align or offset, not both)"
+        }
+      )
+    ),
+    verticalPosition: Type2.Optional(
+      Type2.Object(
+        {
+          relative: Type2.Optional(VerticalPositionRelativeFromSchema),
+          align: Type2.Optional(VerticalPositionAlignSchema),
+          offset: Type2.Optional(
+            Type2.Number({
+              description: "Vertical offset in twips (1/20 of a point)"
+            })
+          )
+        },
+        {
+          description: "Vertical positioning (use either align or offset, not both)"
+        }
+      )
+    ),
+    wrap: Type2.Optional(
+      Type2.Object(
+        {
+          type: TextWrappingTypeSchema,
+          side: Type2.Optional(TextWrappingSideSchema),
+          margins: Type2.Optional(
+            Type2.Object(
+              {
+                top: Type2.Optional(
+                  Type2.Number({ description: "Top margin in twips" })
+                ),
+                bottom: Type2.Optional(
+                  Type2.Number({ description: "Bottom margin in twips" })
+                ),
+                left: Type2.Optional(
+                  Type2.Number({ description: "Left margin in twips" })
+                ),
+                right: Type2.Optional(
+                  Type2.Number({ description: "Right margin in twips" })
+                )
+              },
+              {
+                description: "Distance from text margins"
+              }
+            )
+          )
+        },
+        {
+          description: "Text wrapping configuration"
+        }
+      )
+    ),
+    allowOverlap: Type2.Optional(
+      Type2.Boolean({
+        description: "Allow element to overlap with other elements"
+      })
+    ),
+    behindDocument: Type2.Optional(
+      Type2.Boolean({
+        description: "Place element behind document text"
+      })
+    ),
+    lockAnchor: Type2.Optional(
+      Type2.Boolean({
+        description: "Lock the anchor position"
+      })
+    ),
+    layoutInCell: Type2.Optional(
+      Type2.Boolean({
+        description: "Layout element within table cell"
+      })
+    ),
+    zIndex: Type2.Optional(
+      Type2.Number({
+        minimum: 0,
+        description: "Z-order for overlapping elements (must be non-negative)"
+      })
+    ),
+    rotation: Type2.Optional(
+      Type2.Number({
+        description: "Rotation angle in degrees"
+      })
+    ),
+    visibility: Type2.Optional(
+      Type2.Union([Type2.Literal("hidden"), Type2.Literal("inherit")], {
+        description: "Visibility of the floating element"
+      })
+    )
+  },
+  {
+    description: "Floating element properties"
+  }
+);
+var NumberingSchema = Type2.Object(
+  {
+    start: Type2.Optional(Type2.Number({ minimum: 1 })),
+    style: Type2.Optional(
+      Type2.Union([
+        Type2.Literal("decimal"),
+        Type2.Literal("lowerLetter"),
+        Type2.Literal("upperLetter"),
+        Type2.Literal("lowerRoman"),
+        Type2.Literal("upperRoman")
+      ])
+    ),
+    separator: Type2.Optional(Type2.String())
+  },
+  { description: "Numbering configuration for lists" }
+);
+var BaseComponentFields = {};
+var BaseComponentPropsSchema = Type2.Object(BaseComponentFields, {
+  description: "Base component props",
+  additionalProperties: true
+});
+
+// src/schemas/components/section.ts
+var createSectionPropsSchema = (moduleRef) => Type3.Object(
+  {
+    title: Type3.Optional(
+      Type3.String({
+        description: "Section title (optional)"
+      })
+    ),
+    level: Type3.Optional(
+      Type3.Number({
+        minimum: 1,
+        maximum: 9,
+        description: "Heading level for section title (1-9)",
+        default: 1
+      })
+    ),
+    header: Type3.Optional(
+      Type3.Union([
+        Type3.Array(moduleRef || Type3.Any(), {
+          description: "Section header modules"
+        }),
+        Type3.Literal("linkToPrevious", {
+          description: "Link header to previous section"
+        })
+      ])
+    ),
+    footer: Type3.Optional(
+      Type3.Union([
+        Type3.Array(moduleRef || Type3.Any(), {
+          description: "Section footer modules"
+        }),
+        Type3.Literal("linkToPrevious", {
+          description: "Link footer to previous section"
+        })
+      ])
+    ),
+    pageBreak: Type3.Optional(
+      Type3.Boolean({
+        description: "Insert page break before section",
+        default: true
+      })
+    ),
+    spacing: Type3.Optional(SpacingSchema),
+    page: Type3.Optional(
+      Type3.Object(
+        {
+          size: Type3.Optional(
+            Type3.Union([
+              Type3.Literal("A4"),
+              Type3.Literal("A3"),
+              Type3.Literal("LETTER"),
+              Type3.Literal("LEGAL"),
+              Type3.Object({
+                width: Type3.Number({ minimum: 0 }),
+                height: Type3.Number({ minimum: 0 })
+              })
+            ])
+          ),
+          margins: Type3.Optional(
+            Type3.Object(
+              {
+                top: Type3.Optional(Type3.Number({ minimum: 0 })),
+                bottom: Type3.Optional(Type3.Number({ minimum: 0 })),
+                left: Type3.Optional(Type3.Number({ minimum: 0 })),
+                right: Type3.Optional(Type3.Number({ minimum: 0 })),
+                header: Type3.Optional(Type3.Number({ minimum: 0 })),
+                footer: Type3.Optional(Type3.Number({ minimum: 0 })),
+                gutter: Type3.Optional(Type3.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 Type4 } from "@sinclair/typebox";
+var ColumnDescriptorSchema = Type4.Object(
+  {
+    width: Type4.Optional(
+      Type4.Union([
+        Type4.Number({
+          minimum: 1,
+          description: "Column width in points"
+        }),
+        Type4.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Column width as percentage of available width (e.g., "30%")'
+        }),
+        Type4.Literal("auto", {
+          description: "Auto width: consume remaining space after fixed widths and gaps"
+        })
+      ])
+    ),
+    gap: Type4.Optional(
+      Type4.Union([
+        Type4.Number({
+          minimum: 0,
+          description: "Gap after this column in points"
+        }),
+        Type4.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Gap after this column as percentage of available width (e.g., "5%")'
+        })
+      ])
+    )
+  },
+  { additionalProperties: false }
+);
+var ColumnsPropsSchema = Type4.Object(
+  {
+    columns: Type4.Union([
+      Type4.Number({
+        minimum: 1,
+        description: "Number of equal-width columns (converter will normalize to array)"
+      }),
+      Type4.Array(ColumnDescriptorSchema, {
+        minItems: 1,
+        description: "List of columns in order; width and gap can be points, percentages, or auto width"
+      })
+    ]),
+    gap: Type4.Optional(
+      Type4.Union([
+        Type4.Number({
+          minimum: 0,
+          description: "Default gap applied after each column except the last (points)"
+        }),
+        Type4.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/heading.ts
+import { Type as Type5 } from "@sinclair/typebox";
+var HeadingPropsSchema = Type5.Object(
+  {
+    text: Type5.String({
+      description: "Heading text (required)"
+    }),
+    level: Type5.Optional(HeadingLevelSchema),
+    // Local font override: allows customizing family/size/color/bold/italic/underline
+    // without modifying theme styles. Supports partial overrides.
+    font: Type5.Optional(Type5.Partial(FontDefinitionSchema)),
+    alignment: Type5.Optional(JustifiedAlignmentSchema),
+    spacing: Type5.Optional(SpacingSchema),
+    lineSpacing: Type5.Optional(
+      Type5.Union([Type5.Number({ minimum: 0 }), LineSpacingSchema])
+    ),
+    pageBreak: Type5.Optional(
+      Type5.Boolean({
+        description: "Insert page break before heading"
+      })
+    ),
+    columnBreak: Type5.Optional(
+      Type5.Boolean({
+        description: "Insert column break before heading"
+      })
+    ),
+    numbering: Type5.Optional(
+      Type5.Boolean({
+        description: "Include in numbering"
+      })
+    ),
+    keepNext: Type5.Optional(
+      Type5.Boolean({
+        description: "Keep heading with next paragraph on same page"
+      })
+    ),
+    keepLines: Type5.Optional(
+      Type5.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 Type6 } from "@sinclair/typebox";
+var FrameWrapTypeSchema = Type6.Union(
+  [
+    Type6.Literal("around"),
+    Type6.Literal("none"),
+    Type6.Literal("notBeside"),
+    Type6.Literal("through"),
+    Type6.Literal("tight"),
+    Type6.Literal("auto")
+  ],
+  {
+    description: "Frame text wrapping type"
+  }
+);
+var FrameAnchorTypeSchema = Type6.Union(
+  [Type6.Literal("margin"), Type6.Literal("page"), Type6.Literal("text")],
+  {
+    description: "Frame anchor type"
+  }
+);
+var FrameHorizontalAlignSchema = Type6.Union(
+  [
+    Type6.Literal("left"),
+    Type6.Literal("center"),
+    Type6.Literal("right"),
+    Type6.Literal("inside"),
+    Type6.Literal("outside")
+  ],
+  {
+    description: "Frame horizontal alignment"
+  }
+);
+var FrameVerticalAlignSchema = Type6.Union(
+  [
+    Type6.Literal("top"),
+    Type6.Literal("center"),
+    Type6.Literal("bottom"),
+    Type6.Literal("inside"),
+    Type6.Literal("outside")
+  ],
+  {
+    description: "Frame vertical alignment"
+  }
+);
+var FloatingFramePropertiesSchema = Type6.Object(
+  {
+    horizontalPosition: Type6.Optional(
+      Type6.Object(
+        {
+          relative: Type6.Optional(FrameAnchorTypeSchema),
+          align: Type6.Optional(FrameHorizontalAlignSchema),
+          offset: Type6.Optional(
+            Type6.Number({
+              description: "Horizontal offset in twips (1/20 of a point)"
+            })
+          )
+        },
+        {
+          description: "Horizontal positioning (use either align or offset, not both)"
+        }
+      )
+    ),
+    verticalPosition: Type6.Optional(
+      Type6.Object(
+        {
+          relative: Type6.Optional(FrameAnchorTypeSchema),
+          align: Type6.Optional(FrameVerticalAlignSchema),
+          offset: Type6.Optional(
+            Type6.Number({
+              description: "Vertical offset in twips (1/20 of a point)"
+            })
+          )
+        },
+        {
+          description: "Vertical positioning (use either align or offset, not both)"
+        }
+      )
+    ),
+    wrap: Type6.Optional(
+      Type6.Object(
+        {
+          type: FrameWrapTypeSchema
+        },
+        {
+          description: "Text wrapping configuration"
+        }
+      )
+    ),
+    lockAnchor: Type6.Optional(
+      Type6.Boolean({
+        description: "Lock the anchor position"
+      })
+    ),
+    width: Type6.Optional(
+      Type6.Number({
+        minimum: 1,
+        description: "Frame width in twips (DXA units)"
+      })
+    ),
+    height: Type6.Optional(
+      Type6.Number({
+        minimum: 1,
+        description: "Frame height in twips (DXA units)"
+      })
+    )
+  },
+  {
+    description: "Floating text frame properties"
+  }
+);
+var AlignmentSchema2 = Type6.Union(
+  [
+    Type6.Literal("left"),
+    Type6.Literal("center"),
+    Type6.Literal("right"),
+    Type6.Literal("justify")
+  ],
+  {
+    description: "Paragraph text alignment"
+  }
+);
+var ParagraphPropsSchema = Type6.Object(
+  {
+    text: Type6.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: Type6.Optional(Type6.Partial(FontDefinitionSchema)),
+    // Optional reference to a named style from theme.styles (e.g., 'heading1', 'normal')
+    themeStyle: Type6.Optional(Type6.String()),
+    // Rich-text decoration color for bold segments (kept as top-level behavior option)
+    boldColor: Type6.Optional(Type6.String()),
+    // Paragraph spacing (in points) — limited paragraph-level option allowed
+    spacing: Type6.Optional(SpacingSchema),
+    // Paragraph alignment (moved from font to config level)
+    alignment: Type6.Optional(AlignmentSchema2),
+    pageBreak: Type6.Optional(
+      Type6.Boolean({
+        description: "Insert page break before paragraph"
+      })
+    ),
+    columnBreak: Type6.Optional(
+      Type6.Boolean({
+        description: "Insert column break before paragraph"
+      })
+    ),
+    floating: Type6.Optional(FloatingFramePropertiesSchema),
+    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"
+      })
+    ),
+    id: Type6.Optional(
+      Type6.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/text-box.ts
+import { Type as Type7 } from "@sinclair/typebox";
+var TextBoxPropsSchema = Type7.Object(
+  {
+    width: Type7.Optional(
+      Type7.Union(
+        [
+          Type7.Number({
+            minimum: 1,
+            description: "Text box width in pixels"
+          }),
+          Type7.String({
+            pattern: "^\\d+(\\.\\d+)?%$",
+            description: 'Text box width as percentage (e.g., "50%") relative to content width'
+          })
+        ],
+        {
+          description: 'Text box width in pixels (number) or as percentage string (e.g., "50%")'
+        }
+      )
+    ),
+    height: Type7.Optional(
+      Type7.Union(
+        [
+          Type7.Number({
+            minimum: 1,
+            description: "Text box height in pixels"
+          }),
+          Type7.String({
+            pattern: "^\\d+(\\.\\d+)?%$",
+            description: 'Text box height as percentage (e.g., "50%") relative to content height'
+          })
+        ],
+        {
+          description: 'Text box height in pixels (number) or as percentage string (e.g., "50%")'
+        }
+      )
+    ),
+    floating: Type7.Optional(FloatingPropertiesSchema),
+    style: Type7.Optional(
+      Type7.Object(
+        {
+          padding: Type7.Optional(
+            Type7.Object(
+              {
+                top: Type7.Optional(Type7.Number({ minimum: 0 })),
+                right: Type7.Optional(Type7.Number({ minimum: 0 })),
+                bottom: Type7.Optional(Type7.Number({ minimum: 0 })),
+                left: Type7.Optional(Type7.Number({ minimum: 0 }))
+              },
+              { additionalProperties: false }
+            )
+          ),
+          border: Type7.Optional(
+            Type7.Object(
+              {
+                top: Type7.Optional(
+                  // Reuse border schema semantics: style/width/color
+                  Type7.Object({
+                    style: Type7.Optional(
+                      Type7.Union([
+                        Type7.Literal("solid"),
+                        Type7.Literal("dashed"),
+                        Type7.Literal("dotted"),
+                        Type7.Literal("double"),
+                        Type7.Literal("none")
+                      ])
+                    ),
+                    width: Type7.Optional(Type7.Number({ minimum: 0 })),
+                    color: Type7.Optional(HexColorSchema)
+                  })
+                ),
+                right: Type7.Optional(
+                  Type7.Object({
+                    style: Type7.Optional(
+                      Type7.Union([
+                        Type7.Literal("solid"),
+                        Type7.Literal("dashed"),
+                        Type7.Literal("dotted"),
+                        Type7.Literal("double"),
+                        Type7.Literal("none")
+                      ])
+                    ),
+                    width: Type7.Optional(Type7.Number({ minimum: 0 })),
+                    color: Type7.Optional(HexColorSchema)
+                  })
+                ),
+                bottom: Type7.Optional(
+                  Type7.Object({
+                    style: Type7.Optional(
+                      Type7.Union([
+                        Type7.Literal("solid"),
+                        Type7.Literal("dashed"),
+                        Type7.Literal("dotted"),
+                        Type7.Literal("double"),
+                        Type7.Literal("none")
+                      ])
+                    ),
+                    width: Type7.Optional(Type7.Number({ minimum: 0 })),
+                    color: Type7.Optional(HexColorSchema)
+                  })
+                ),
+                left: Type7.Optional(
+                  Type7.Object({
+                    style: Type7.Optional(
+                      Type7.Union([
+                        Type7.Literal("solid"),
+                        Type7.Literal("dashed"),
+                        Type7.Literal("dotted"),
+                        Type7.Literal("double"),
+                        Type7.Literal("none")
+                      ])
+                    ),
+                    width: Type7.Optional(Type7.Number({ minimum: 0 })),
+                    color: Type7.Optional(HexColorSchema)
+                  })
+                )
+              },
+              { additionalProperties: false }
+            )
+          ),
+          shading: Type7.Optional(
+            Type7.Object(
+              {
+                fill: Type7.Optional(Type7.String())
+              },
+              { additionalProperties: false }
+            )
+          )
+        },
+        { additionalProperties: false }
+      )
+    )
+  },
+  { additionalProperties: false }
+);
+
+// src/schemas/components/image.ts
+import { Type as Type8 } from "@sinclair/typebox";
+var ImagePropsSchema = Type8.Object(
+  {
+    path: Type8.Optional(
+      Type8.String({
+        description: "Image source URL or file path (mutually exclusive with base64)"
+      })
+    ),
+    base64: Type8.Optional(
+      Type8.String({
+        description: 'Base64-encoded image data in data URI format (e.g., "data:image/png;base64,iVBORw0KGgo...") (mutually exclusive with path)'
+      })
+    ),
+    alt: Type8.Optional(
+      Type8.String({
+        description: "Alternative text for accessibility"
+      })
+    ),
+    width: Type8.Optional(
+      Type8.Union(
+        [
+          Type8.Number({
+            minimum: 1,
+            description: "Image width in pixels"
+          }),
+          Type8.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: Type8.Optional(
+      Type8.Union(
+        [
+          Type8.Number({
+            minimum: 1,
+            description: "Image height in pixels"
+          }),
+          Type8.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: Type8.Optional(
+      Type8.Union([Type8.Literal("content"), Type8.Literal("page")], {
+        description: "Reference for width percentages: content (page width minus margins) or page (full page width)",
+        default: "content"
+      })
+    ),
+    heightRelativeTo: Type8.Optional(
+      Type8.Union([Type8.Literal("content"), Type8.Literal("page")], {
+        description: "Reference for height percentages: content (page height minus margins) or page (full page height)",
+        default: "content"
+      })
+    ),
+    alignment: Type8.Optional(AlignmentSchema),
+    caption: Type8.Optional(
+      Type8.String({
+        description: "Image caption (supports rich text with **bold**, *italic*, ***both***)"
+      })
+    ),
+    spacing: Type8.Optional(SpacingSchema),
+    floating: Type8.Optional(FloatingPropertiesSchema),
+    keepNext: Type8.Optional(
+      Type8.Boolean({
+        description: "Keep paragraph with next paragraph on same page"
+      })
+    ),
+    keepLines: Type8.Optional(
+      Type8.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 Type9 } from "@sinclair/typebox";
+var StatisticPropsSchema = Type9.Object(
+  {
+    number: Type9.String({
+      description: "Statistic number/value (required)"
+    }),
+    description: Type9.String({
+      description: "Statistic description (required)"
+    }),
+    unit: Type9.Optional(
+      Type9.String({
+        description: "Unit of measurement"
+      })
+    ),
+    format: Type9.Optional(
+      Type9.String({
+        description: "Number format pattern"
+      })
+    ),
+    trend: Type9.Optional(
+      Type9.Union([
+        Type9.Literal("up"),
+        Type9.Literal("down"),
+        Type9.Literal("neutral")
+      ])
+    ),
+    trendValue: Type9.Optional(Type9.Union([Type9.String(), Type9.Number()])),
+    alignment: Type9.Optional(AlignmentSchema),
+    spacing: Type9.Optional(SpacingSchema),
+    size: Type9.Optional(
+      Type9.Union([
+        Type9.Literal("small"),
+        Type9.Literal("medium"),
+        Type9.Literal("large")
+      ])
+    )
+  },
+  {
+    description: "Statistic component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/table.ts
+import { Type as Type10 } from "@sinclair/typebox";
+var CellContentSchema = Type10.Recursive(
+  (This) => Type10.Union([
+    Type10.String(),
+    Type10.Object(
+      {
+        name: Type10.String(),
+        props: Type10.Object({}, { additionalProperties: true }),
+        children: Type10.Optional(Type10.Array(This))
+      },
+      { additionalProperties: false }
+    )
+  ])
+);
+var HorizontalAlignmentSchema = Type10.Union(
+  [
+    Type10.Literal("left"),
+    Type10.Literal("center"),
+    Type10.Literal("right"),
+    Type10.Literal("justify")
+  ],
+  { description: "Horizontal text alignment" }
+);
+var VerticalAlignmentSchema = Type10.Union(
+  [Type10.Literal("top"), Type10.Literal("middle"), Type10.Literal("bottom")],
+  { description: "Vertical cell alignment" }
+);
+var FontConfigSchema = Type10.Object({
+  family: Type10.Optional(Type10.String({ description: "Font family name" })),
+  size: Type10.Optional(
+    Type10.Number({ minimum: 0, description: "Font size in points" })
+  ),
+  bold: Type10.Optional(Type10.Boolean({ description: "Bold text" })),
+  italic: Type10.Optional(Type10.Boolean({ description: "Italic text" })),
+  underline: Type10.Optional(Type10.Boolean({ description: "Underlined text" }))
+});
+var BorderColorSchema = Type10.Union([
+  Type10.String({ description: "Border color for all sides (hex without #)" }),
+  Type10.Object({
+    bottom: Type10.Optional(
+      Type10.String({ description: "Bottom border color (hex without #)" })
+    ),
+    top: Type10.Optional(
+      Type10.String({ description: "Top border color (hex without #)" })
+    ),
+    right: Type10.Optional(
+      Type10.String({ description: "Right border color (hex without #)" })
+    ),
+    left: Type10.Optional(
+      Type10.String({ description: "Left border color (hex without #)" })
+    )
+  })
+]);
+var BorderSizeSchema = Type10.Union([
+  Type10.Number({
+    minimum: 0,
+    description: "Border size for all sides in points"
+  }),
+  Type10.Object({
+    bottom: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Bottom border size in points" })
+    ),
+    top: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Top border size in points" })
+    ),
+    right: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Right border size in points" })
+    ),
+    left: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Left border size in points" })
+    )
+  })
+]);
+var HideBordersSchema = Type10.Union([
+  Type10.Boolean({
+    description: "Hide all borders when true"
+  }),
+  Type10.Object(
+    {
+      bottom: Type10.Optional(
+        Type10.Boolean({ description: "Hide bottom border" })
+      ),
+      top: Type10.Optional(Type10.Boolean({ description: "Hide top border" })),
+      right: Type10.Optional(Type10.Boolean({ description: "Hide right border" })),
+      left: Type10.Optional(Type10.Boolean({ description: "Hide left border" })),
+      insideHorizontal: Type10.Optional(
+        Type10.Boolean({ description: "Hide horizontal borders between rows" })
+      ),
+      insideVertical: Type10.Optional(
+        Type10.Boolean({ description: "Hide vertical borders between columns" })
+      )
+    },
+    { description: "Selectively hide specific borders" }
+  )
+]);
+var PaddingSchema = Type10.Union([
+  Type10.Number({ minimum: 0, description: "Padding for all sides in points" }),
+  Type10.Object({
+    bottom: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Bottom padding in points" })
+    ),
+    top: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Top padding in points" })
+    ),
+    right: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Right padding in points" })
+    ),
+    left: Type10.Optional(
+      Type10.Number({ minimum: 0, description: "Left padding in points" })
+    )
+  })
+]);
+var CellDefaultsSchema = Type10.Object({
+  color: Type10.Optional(HexColorSchema),
+  backgroundColor: Type10.Optional(HexColorSchema),
+  horizontalAlignment: Type10.Optional(HorizontalAlignmentSchema),
+  verticalAlignment: Type10.Optional(VerticalAlignmentSchema),
+  font: Type10.Optional(FontConfigSchema),
+  borderColor: Type10.Optional(BorderColorSchema),
+  borderSize: Type10.Optional(BorderSizeSchema),
+  padding: Type10.Optional(PaddingSchema),
+  height: Type10.Optional(
+    Type10.Number({ minimum: 0, description: "Cell height in points" })
+  )
+});
+var HeaderSchema = Type10.Object({
+  color: Type10.Optional(HexColorSchema),
+  backgroundColor: Type10.Optional(HexColorSchema),
+  horizontalAlignment: Type10.Optional(HorizontalAlignmentSchema),
+  verticalAlignment: Type10.Optional(VerticalAlignmentSchema),
+  font: Type10.Optional(FontConfigSchema),
+  borderColor: Type10.Optional(BorderColorSchema),
+  borderSize: Type10.Optional(BorderSizeSchema),
+  padding: Type10.Optional(PaddingSchema),
+  height: Type10.Optional(
+    Type10.Number({ minimum: 0, description: "Cell height in points" })
+  ),
+  content: Type10.Optional(CellContentSchema)
+});
+var CellSchema = Type10.Object({
+  color: Type10.Optional(HexColorSchema),
+  backgroundColor: Type10.Optional(HexColorSchema),
+  horizontalAlignment: Type10.Optional(HorizontalAlignmentSchema),
+  verticalAlignment: Type10.Optional(VerticalAlignmentSchema),
+  font: Type10.Optional(FontConfigSchema),
+  borderColor: Type10.Optional(BorderColorSchema),
+  borderSize: Type10.Optional(BorderSizeSchema),
+  padding: Type10.Optional(PaddingSchema),
+  height: Type10.Optional(
+    Type10.Number({ minimum: 0, description: "Cell height in points" })
+  ),
+  content: Type10.Optional(CellContentSchema)
+});
+var ColumnSchema = Type10.Object({
+  width: Type10.Optional(
+    Type10.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."
+    })
+  ),
+  cellDefaults: Type10.Optional(CellDefaultsSchema),
+  header: Type10.Optional(HeaderSchema),
+  cells: Type10.Optional(Type10.Array(CellSchema))
+});
+var TablePropsSchema = Type10.Object(
+  {
+    borderColor: Type10.Optional(BorderColorSchema),
+    borderSize: Type10.Optional(BorderSizeSchema),
+    hideBorders: Type10.Optional(HideBordersSchema),
+    cellDefaults: Type10.Optional(CellDefaultsSchema),
+    headerCellDefaults: Type10.Optional(CellDefaultsSchema),
+    width: Type10.Optional(
+      Type10.Number({
+        minimum: 0,
+        maximum: 100,
+        description: "Table width in percentage (0-100)"
+      })
+    ),
+    columns: Type10.Array(ColumnSchema, {
+      description: "Table columns with headers and cells",
+      minItems: 1
+    }),
+    keepInOnePage: Type10.Optional(
+      Type10.Boolean({
+        description: "Keep table rows together on the same page by setting keepNext on all paragraphs"
+      })
+    ),
+    keepNext: Type10.Optional(
+      Type10.Boolean({
+        description: "Set keepNext on the last row to keep it connected to the next element. Works independently of keepInOnePage. Defaults to false."
+      })
+    ),
+    repeatHeaderOnPageBreak: Type10.Optional(
+      Type10.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"
+  }
+);
+
+// src/schemas/components/header.ts
+import { Type as Type11 } from "@sinclair/typebox";
+var HeaderPropsSchema = Type11.Object(
+  {
+    text: Type11.Optional(
+      Type11.String({
+        description: "Header text"
+      })
+    ),
+    logo: Type11.Optional(
+      Type11.String({
+        description: "Logo image URL or path"
+      })
+    ),
+    alignment: Type11.Optional(AlignmentSchema),
+    position: Type11.Optional(
+      Type11.Union([Type11.Literal("top"), Type11.Literal("bottom")])
+    ),
+    firstPage: Type11.Optional(
+      Type11.Boolean({
+        description: "Show header on first page"
+      })
+    ),
+    oddPages: Type11.Optional(
+      Type11.Boolean({
+        description: "Show header on odd pages"
+      })
+    ),
+    evenPages: Type11.Optional(
+      Type11.Boolean({
+        description: "Show header on even pages"
+      })
+    ),
+    showPageNumbers: Type11.Optional(Type11.Boolean()),
+    showDate: Type11.Optional(Type11.Boolean()),
+    height: Type11.Optional(Type11.Number({ minimum: 0 }))
+  },
+  {
+    description: "Document header configuration",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/footer.ts
+import { Type as Type12 } from "@sinclair/typebox";
+var FooterPropsSchema = Type12.Object(
+  {
+    text: Type12.Optional(
+      Type12.String({
+        description: "Footer text"
+      })
+    ),
+    alignment: Type12.Optional(AlignmentSchema),
+    position: Type12.Optional(
+      Type12.Union([Type12.Literal("top"), Type12.Literal("bottom")])
+    ),
+    firstPage: Type12.Optional(
+      Type12.Boolean({
+        description: "Show footer on first page"
+      })
+    ),
+    oddPages: Type12.Optional(
+      Type12.Boolean({
+        description: "Show footer on odd pages"
+      })
+    ),
+    evenPages: Type12.Optional(
+      Type12.Boolean({
+        description: "Show footer on even pages"
+      })
+    ),
+    showPageNumbers: Type12.Optional(Type12.Boolean()),
+    showDate: Type12.Optional(Type12.Boolean()),
+    height: Type12.Optional(Type12.Number({ minimum: 0 }))
+  },
+  {
+    description: "Document footer configuration",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/list.ts
+import { Type as Type13 } from "@sinclair/typebox";
+var LevelFormatSchema = Type13.Union(
+  [
+    Type13.Literal("decimal"),
+    Type13.Literal("upperRoman"),
+    Type13.Literal("lowerRoman"),
+    Type13.Literal("upperLetter"),
+    Type13.Literal("lowerLetter"),
+    Type13.Literal("bullet"),
+    Type13.Literal("ordinal"),
+    Type13.Literal("cardinalText"),
+    Type13.Literal("ordinalText"),
+    Type13.Literal("hex"),
+    Type13.Literal("chicago"),
+    Type13.Literal("ideographDigital"),
+    Type13.Literal("japaneseCounting"),
+    Type13.Literal("aiueo"),
+    Type13.Literal("iroha"),
+    Type13.Literal("decimalFullWidth"),
+    Type13.Literal("decimalHalfWidth"),
+    Type13.Literal("japaneseLegal"),
+    Type13.Literal("japaneseDigitalTenThousand"),
+    Type13.Literal("decimalEnclosedCircle"),
+    Type13.Literal("decimalFullWidth2"),
+    Type13.Literal("aiueoFullWidth"),
+    Type13.Literal("irohaFullWidth"),
+    Type13.Literal("decimalZero"),
+    Type13.Literal("ganada"),
+    Type13.Literal("chosung"),
+    Type13.Literal("decimalEnclosedFullstop"),
+    Type13.Literal("decimalEnclosedParen"),
+    Type13.Literal("decimalEnclosedCircleChinese"),
+    Type13.Literal("ideographEnclosedCircle"),
+    Type13.Literal("ideographTraditional"),
+    Type13.Literal("ideographZodiac"),
+    Type13.Literal("ideographZodiacTraditional"),
+    Type13.Literal("taiwaneseCounting"),
+    Type13.Literal("ideographLegalTraditional"),
+    Type13.Literal("taiwaneseCountingThousand"),
+    Type13.Literal("taiwaneseDigital"),
+    Type13.Literal("chineseCounting"),
+    Type13.Literal("chineseLegalSimplified"),
+    Type13.Literal("chineseCountingThousand"),
+    Type13.Literal("koreanDigital"),
+    Type13.Literal("koreanCounting"),
+    Type13.Literal("koreanLegal"),
+    Type13.Literal("koreanDigital2"),
+    Type13.Literal("vietnameseCounting"),
+    Type13.Literal("russianLower"),
+    Type13.Literal("russianUpper"),
+    Type13.Literal("none"),
+    Type13.Literal("numberInDash"),
+    Type13.Literal("hebrew1"),
+    Type13.Literal("hebrew2"),
+    Type13.Literal("arabicAlpha"),
+    Type13.Literal("arabicAbjad"),
+    Type13.Literal("hindiVowels"),
+    Type13.Literal("hindiConsonants"),
+    Type13.Literal("hindiNumbers"),
+    Type13.Literal("hindiCounting"),
+    Type13.Literal("thaiLetters"),
+    Type13.Literal("thaiNumbers"),
+    Type13.Literal("thaiCounting")
+  ],
+  {
+    description: "Number or bullet format for list levels"
+  }
+);
+var ListLevelPropsSchema = Type13.Object(
+  {
+    level: Type13.Number({
+      minimum: 0,
+      maximum: 8,
+      description: "Nesting level (0 = root, 1 = first sublevel, etc.)"
+    }),
+    format: Type13.Optional(LevelFormatSchema),
+    text: Type13.Optional(
+      Type13.String({
+        description: 'Number format string (e.g., "%1." for "1.", "%1)" for "1)", custom bullet character for bullet format)'
+      })
+    ),
+    alignment: Type13.Optional(
+      Type13.Union(
+        [
+          Type13.Literal("start"),
+          Type13.Literal("end"),
+          Type13.Literal("left"),
+          Type13.Literal("right"),
+          Type13.Literal("center")
+        ],
+        {
+          description: "Alignment of the numbering/bullet"
+        }
+      )
+    ),
+    indent: Type13.Optional(IndentSchema),
+    start: Type13.Optional(
+      Type13.Number({
+        minimum: 1,
+        description: "Starting number for this level (default: 1)"
+      })
+    )
+  },
+  {
+    description: "Configuration for a single list level"
+  }
+);
+var ListPropsSchema = Type13.Object(
+  {
+    items: Type13.Array(
+      Type13.Union([
+        Type13.String(),
+        Type13.Object({
+          text: Type13.String(),
+          level: Type13.Optional(
+            Type13.Number({
+              minimum: 0,
+              maximum: 8,
+              description: "Nesting level for this item"
+            })
+          )
+        })
+      ]),
+      {
+        description: "List items (required)",
+        minItems: 1
+      }
+    ),
+    reference: Type13.Optional(
+      Type13.String({
+        description: "Unique reference ID for this numbering configuration (auto-generated if not provided)"
+      })
+    ),
+    levels: Type13.Optional(
+      Type13.Array(ListLevelPropsSchema, {
+        description: "Configuration for each nesting level",
+        minItems: 1,
+        maxItems: 9
+      })
+    ),
+    // Simplified options for common use cases (when levels not specified)
+    format: Type13.Optional(
+      Type13.Union(
+        [LevelFormatSchema, Type13.Literal("numbered"), Type13.Literal("none")],
+        {
+          description: "Format for level 0 (simplified option when levels not specified)"
+        }
+      )
+    ),
+    bullet: Type13.Optional(
+      Type13.String({
+        description: "Custom bullet character (simplified option when levels not specified)"
+      })
+    ),
+    start: Type13.Optional(
+      Type13.Number({
+        minimum: 1,
+        description: "Starting number for level 0 (simplified option when levels not specified)"
+      })
+    ),
+    spacing: Type13.Optional(ListSpacingSchema),
+    alignment: Type13.Optional(JustifiedAlignmentSchema),
+    indent: Type13.Optional(
+      Type13.Union([Type13.Number({ minimum: 0 }), IndentSchema])
+    )
+  },
+  {
+    description: "List component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/toc.ts
+import { Type as Type14 } from "@sinclair/typebox";
+var TocStyleSchema = Type14.Union(
+  [Type14.Literal("numeric"), Type14.Literal("bullet"), Type14.Literal("none")],
+  { description: "TOC numbering style" }
+);
+var TocScopeSchema = Type14.Union(
+  [Type14.Literal("document"), Type14.Literal("section")],
+  { description: "TOC scope: document-wide or section-only" }
+);
+var TocStyleMappingSchema = Type14.Object(
+  {
+    styleId: Type14.String({
+      description: "Custom style ID matching a key in theme.styles"
+    }),
+    level: Type14.Number({
+      minimum: 1,
+      maximum: 6,
+      description: "TOC level (1-6) to assign to this style"
+    })
+  },
+  {
+    description: "Mapping of custom style to TOC level",
+    additionalProperties: false
+  }
+);
+var TocDepthRangeSchema = Type14.Object(
+  {
+    from: Type14.Optional(
+      Type14.Number({
+        minimum: 1,
+        maximum: 6,
+        default: 1,
+        description: "Starting heading level (1-6). Defaults to 1 if not specified."
+      })
+    ),
+    to: Type14.Optional(
+      Type14.Number({
+        minimum: 1,
+        maximum: 6,
+        default: 3,
+        description: "Ending heading level (1-6). Defaults to 3 if not specified."
+      })
+    )
+  },
+  {
+    description: 'Range of heading levels to include in TOC. Specify at least one of "from" or "to".',
+    additionalProperties: false
+  }
+);
+var TocPropsSchema = Type14.Object(
+  {
+    pageBreak: Type14.Optional(
+      Type14.Boolean({
+        description: "Insert page break before TOC block"
+      })
+    ),
+    depth: Type14.Optional(
+      Type14.Object(
+        {
+          from: Type14.Optional(
+            Type14.Number({
+              minimum: 1,
+              maximum: 6,
+              default: 1,
+              description: "Starting heading level (1-6). Defaults to 1 if not specified."
+            })
+          ),
+          to: Type14.Optional(
+            Type14.Number({
+              minimum: 1,
+              maximum: 6,
+              default: 3,
+              description: "Ending heading level (1-6). Defaults to 3 if not specified."
+            })
+          )
+        },
+        {
+          description: 'Range of heading levels to include in TOC. Specify "from", "to", or both. Defaults: from=1, to=3',
+          additionalProperties: false,
+          default: { to: 3 }
+        }
+      )
+    ),
+    pageNumbersDepth: Type14.Optional(
+      Type14.Object(
+        {
+          from: Type14.Optional(
+            Type14.Number({
+              minimum: 1,
+              maximum: 6,
+              default: 1,
+              description: "Starting heading level (1-6). Defaults to 1 if not specified."
+            })
+          ),
+          to: Type14.Optional(
+            Type14.Number({
+              minimum: 1,
+              maximum: 6,
+              default: 3,
+              description: "Ending heading level (1-6). Defaults to 3 if not specified."
+            })
+          )
+        },
+        {
+          description: 'Range of heading levels to show page numbers. Specify "from", "to", or both. When specified, page numbers are hidden for entries outside this range.',
+          additionalProperties: false
+        }
+      )
+    ),
+    numberingStyle: Type14.Optional(TocStyleSchema),
+    title: Type14.Optional(
+      Type14.String({
+        description: "TOC heading title"
+      })
+    ),
+    includePageNumbers: Type14.Optional(
+      Type14.Boolean({
+        default: true,
+        description: "Show page numbers next to entries"
+      })
+    ),
+    numberSeparator: Type14.Optional(
+      Type14.Boolean({
+        default: true,
+        description: 'Use tab separator between entry and page number. True applies "\\t" (default), false applies " "'
+      })
+    ),
+    scope: Type14.Optional(
+      Type14.Union([TocScopeSchema, Type14.Literal("auto")], {
+        default: "auto",
+        description: 'TOC scope: "document" for entire document, "section" for parent section only, "auto" for automatic detection (section if inside section, otherwise document)'
+      })
+    ),
+    styles: Type14.Optional(
+      Type14.Array(TocStyleMappingSchema, {
+        description: "Custom style mappings for TOC entries. Maps custom theme styles to TOC levels."
+      })
+    )
+  },
+  {
+    description: "Table of Contents component props",
+    additionalProperties: false
+  }
+);
+
+// src/schemas/components/highcharts.ts
+import { Type as Type15 } from "@sinclair/typebox";
+var HighchartsPropsSchema = Type15.Object({
+  // Highcharts chart options - can be anything but must at least have chart.width and chart.height
+  options: Type15.Intersect([
+    Type15.Record(Type15.String(), Type15.Unknown()),
+    Type15.Object({
+      chart: Type15.Object({
+        width: Type15.Number(),
+        height: Type15.Number()
+      })
+    })
+  ]),
+  // Optional scale factor for export
+  scale: Type15.Optional(Type15.Number()),
+  // Optional Highcharts Export Server URL override
+  serverUrl: Type15.Optional(Type15.String({ description: "Highcharts Export Server URL (default: http://localhost:7801)" })),
+  // Optional width for rendering (overrides chart width)
+  width: Type15.Optional(
+    Type15.Union(
+      [
+        Type15.Number({
+          minimum: 1,
+          description: "Image width in pixels"
+        }),
+        Type15.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Image width as percentage (e.g., "90%") relative to content width'
+        })
+      ],
+      {
+        description: 'Rendered image width in pixels (number) or as percentage string (e.g., "90%")'
+      }
+    )
+  ),
+  // Optional height for rendering (overrides chart height)
+  height: Type15.Optional(
+    Type15.Union(
+      [
+        Type15.Number({
+          minimum: 1,
+          description: "Image height in pixels"
+        }),
+        Type15.String({
+          pattern: "^\\d+(\\.\\d+)?%$",
+          description: 'Image height as percentage (e.g., "90%") relative to content height'
+        })
+      ],
+      {
+        description: 'Rendered image height in pixels (number) or as percentage string (e.g., "90%")'
+      }
+    )
+  )
+});
+
+// src/schemas/component-registry.ts
+var STANDARD_COMPONENTS_REGISTRY = [
+  // ========================================================================
+  // Container Components (can contain children)
+  // ========================================================================
+  {
+    name: "docx",
+    propsSchema: ReportPropsSchema,
+    hasChildren: true,
+    category: "container",
+    description: "Main document container - defines the overall document structure. Required as the root component.",
+    special: {
+      hasSchemaField: true
+      // Only docx root has $schema field
+    }
+  },
+  {
+    name: "section",
+    propsSchema: SectionPropsSchema,
+    hasChildren: true,
+    category: "container",
+    description: "Section container - groups related content with optional title. Use for organizing document structure."
+  },
+  {
+    name: "columns",
+    propsSchema: ColumnsPropsSchema,
+    hasChildren: true,
+    category: "layout",
+    description: "Multi-column layout - arranges content in 2-4 columns. Great for side-by-side content."
+  },
+  {
+    name: "text-box",
+    propsSchema: TextBoxPropsSchema,
+    hasChildren: true,
+    category: "layout",
+    description: "Floating text container - allows positioning text anywhere on the page with absolute or relative positioning."
+  },
+  // ========================================================================
+  // Content Components (leaf nodes, no children)
+  // ========================================================================
+  {
+    name: "heading",
+    propsSchema: HeadingPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Heading text - supports levels 1-6 for document hierarchy. Level 1 is largest."
+  },
+  {
+    name: "paragraph",
+    propsSchema: ParagraphPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Paragraph text - supports formatting like bold, italic, and color. Main content element."
+  },
+  {
+    name: "image",
+    propsSchema: ImagePropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Image element - displays images with optional caption. Supports various formats."
+  },
+  {
+    name: "statistic",
+    propsSchema: StatisticPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Statistic display - shows a number with description. Perfect for KPIs and metrics."
+  },
+  {
+    name: "table",
+    propsSchema: TablePropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Data table - displays tabular data with headers. Supports formatting and alignment."
+  },
+  {
+    name: "header",
+    propsSchema: HeaderPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Page header - appears at the top of pages. Can include text and page numbers."
+  },
+  {
+    name: "footer",
+    propsSchema: FooterPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Page footer - appears at the bottom of pages. Can include text and page numbers."
+  },
+  {
+    name: "list",
+    propsSchema: ListPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "List element - bulleted or numbered list items. Supports nested lists."
+  },
+  {
+    name: "toc",
+    propsSchema: TocPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Table of contents - automatically generates TOC from document headings. Supports depth ranges and custom styles."
+  },
+  {
+    name: "highcharts",
+    propsSchema: HighchartsPropsSchema,
+    hasChildren: false,
+    category: "content",
+    description: "Chart component powered by Highcharts - render line, bar, pie, heatmap, and more with rich options."
+  }
+];
+function getStandardComponent(name) {
+  return STANDARD_COMPONENTS_REGISTRY.find((c) => c.name === name);
+}
+function getAllStandardComponentNames() {
+  return STANDARD_COMPONENTS_REGISTRY.map((c) => c.name);
+}
+function getComponentsByCategory(category) {
+  return STANDARD_COMPONENTS_REGISTRY.filter((c) => c.category === category);
+}
+function getContainerComponents() {
+  return STANDARD_COMPONENTS_REGISTRY.filter((c) => c.hasChildren);
+}
+function getContentComponents() {
+  return STANDARD_COMPONENTS_REGISTRY.filter((c) => !c.hasChildren);
+}
+function isStandardComponent(name) {
+  return STANDARD_COMPONENTS_REGISTRY.some((c) => c.name === name);
+}
+function createComponentSchemaObject(component, recursiveRef) {
+  const schema = {
+    name: Type16.Literal(component.name),
+    id: Type16.Optional(Type16.String()),
+    enabled: Type16.Optional(
+      Type16.Boolean({
+        default: true,
+        description: "When false, this component is filtered out and not rendered. Defaults to true. Useful for conditional component inclusion."
+      })
+    )
+  };
+  if (component.special?.hasSchemaField) {
+    schema.$schema = Type16.Optional(Type16.String({ format: "uri" }));
+  }
+  schema.props = component.propsSchema;
+  if (component.hasChildren && recursiveRef) {
+    schema.children = Type16.Optional(Type16.Array(recursiveRef));
+  }
+  return Type16.Object(schema, { additionalProperties: false });
+}
+function createAllComponentSchemas(recursiveRef) {
+  return STANDARD_COMPONENTS_REGISTRY.map(
+    (component) => createComponentSchemaObject(component, recursiveRef)
+  );
+}
+
+export {
+  createReportPropsSchema,
+  ReportPropsSchema,
+  AlignmentSchema,
+  JustifiedAlignmentSchema,
+  HeadingLevelSchema,
+  SpacingSchema,
+  ListSpacingSchema,
+  MarginsSchema,
+  BorderSchema,
+  LineSpacingSchema,
+  IndentSchema,
+  HorizontalPositionRelativeFromSchema,
+  VerticalPositionRelativeFromSchema,
+  HorizontalPositionAlignSchema,
+  VerticalPositionAlignSchema,
+  TextWrappingTypeSchema,
+  TextWrappingSideSchema,
+  FloatingPropertiesSchema,
+  NumberingSchema,
+  BaseComponentFields,
+  BaseComponentPropsSchema,
+  createSectionPropsSchema,
+  SectionPropsSchema,
+  ColumnsPropsSchema,
+  HeadingPropsSchema,
+  ParagraphPropsSchema,
+  TextBoxPropsSchema,
+  ImagePropsSchema,
+  StatisticPropsSchema,
+  TablePropsSchema,
+  HeaderPropsSchema,
+  FooterPropsSchema,
+  LevelFormatSchema,
+  ListLevelPropsSchema,
+  ListPropsSchema,
+  TocStyleSchema,
+  TocScopeSchema,
+  TocStyleMappingSchema,
+  TocDepthRangeSchema,
+  TocPropsSchema,
+  HighchartsPropsSchema,
+  STANDARD_COMPONENTS_REGISTRY,
+  getStandardComponent,
+  getAllStandardComponentNames,
+  getComponentsByCategory,
+  getContainerComponents,
+  getContentComponents,
+  isStandardComponent,
+  createComponentSchemaObject,
+  createAllComponentSchemas
+};
+//# sourceMappingURL=chunk-5533WPL6.js.map