ts-d2 0.0.21 → 0.0.22

package/dist/index.d.cts

@@ -5,12 +5,6 @@ declare abstract class DocumentElement {
 }
 type Content = string | DocumentElement | (DocumentElement | string)[];
 
-declare class Text extends DocumentElement {
-    constructor(content: string);
-    content: string;
-    toDocFrame(): Proto.Node;
-}
-
 declare abstract class BranchDocumentElement<P = never> extends DocumentElement {
     protected children: DocumentElement[];
     protected _props?: P;
@@ -24,6 +18,58 @@ declare abstract class BranchDocumentElement<P = never> extends DocumentElement
     get props(): P | undefined;
 }
 
+/**
+ * WsArea (Widow/orphan and Split area) wraps content to control
+ * page break behavior.
+ */
+declare class WsArea extends BranchDocumentElement {
+    constructor(content?: Content);
+    toDocFrame(): Proto.Node;
+}
+
+type VariableSpecialType = "table-number" | "doc-page-count" | "doc-cur-page" | "cur-page" | "page-count" | "prev-page" | "section-page" | "updated-at" | "generated-at";
+interface VariableProperties {
+    /** Data path to the variable */
+    path?: string;
+    /** Static content value */
+    content?: string;
+    /** UUID of the format to apply */
+    formatUuid?: string;
+    /** Special type of the variable (e.g. page number) */
+    specialType?: VariableSpecialType;
+    /** UUID */
+    uuid?: string;
+}
+declare class Variable extends DocumentElement {
+    props: VariableProperties;
+    constructor(props: VariableProperties);
+    toDocFrame(): Proto.Node;
+}
+
+declare class Text extends DocumentElement {
+    constructor(content: string);
+    content: string;
+    toDocFrame(): Proto.Node;
+}
+
+interface TagProperties {
+    /** Tag name */
+    name: string;
+    /** UUID */
+    uuid?: string;
+    /** Tag parameters */
+    params?: string[];
+    /** Name code expression */
+    nameCode?: string;
+    /** Whether name is in code mode */
+    codeMode?: boolean;
+}
+declare class Tag extends DocumentElement {
+    props: TagProperties;
+    constructor(props: TagProperties);
+    toDocFrame(): Proto.Node;
+}
+
 type AbsoluteMeasureUnit = "pt" | "cm" | "mm" | "in" | "px";
 type RelativeMeasureUnit = "%";
 type MeasureUnit = AbsoluteMeasureUnit | RelativeMeasureUnit;
@@ -66,6 +112,15 @@ declare class TableRow extends BranchDocumentElement<TableRowProperties> {
     toDocFrame(): Proto.Node;
 }
 
+interface TableContentGroupProperties {
+    /** UUID */
+    uuid?: string;
+}
+declare class TableContentGroup extends BranchDocumentElement<TableContentGroupProperties> {
+    constructor(content?: Content, props?: TableContentGroupProperties);
+    toDocFrame(): Proto.Node;
+}
+
 declare class HorizontalAlignment {
     readonly value: Proto.ProtoHorizontalAlignment;
     constructor(value: Proto.ProtoHorizontalAlignment);
@@ -76,6 +131,20 @@ declare class VerticalAlignment {
     constructor(value: Proto.ProtoVerticalAlignment);
     toDocFrame(): Proto.ProtoVerticalAlignment;
 }
+declare namespace Alignment {
+    const Horizontal: {
+        Left: HorizontalAlignment;
+        Center: HorizontalAlignment;
+        Right: HorizontalAlignment;
+        Justify: HorizontalAlignment;
+        FullJustify: HorizontalAlignment;
+    };
+    const Vertical: {
+        Top: VerticalAlignment;
+        Middle: VerticalAlignment;
+        Bottom: VerticalAlignment;
+    };
+}
 
 declare class Color {
     private color;
@@ -110,6 +179,8 @@ interface TableCellProperties {
     padding?: SideMeasures;
     verticalAlignment?: VerticalAlignment;
     width?: Measure$1;
+    rotation?: number;
+    defaultParagraphFormat?: string;
 }
 declare class TableCell extends BranchDocumentElement<TableCellProperties> {
     constructor(content?: Content, props?: TableCellProperties);
@@ -119,17 +190,36 @@ declare class TableCell extends BranchDocumentElement<TableCellProperties> {
 interface TableSettings {
     width?: Measure$1;
     xOffset?: Measure$1;
+    leftMeasure?: boolean;
+    repeatHeader?: number;
 }
 declare class Table extends BranchDocumentElement<TableSettings> {
     constructor(content?: Content, props?: TableSettings);
     toDocFrame(): Proto.Node;
 }
 
+type SubTotalPosition = "above-footer" | "below-content";
+interface SubTotalProperties {
+    /** Whether to apply immediately */
+    applyImmediate?: boolean;
+    /** Position of the sub total */
+    position?: SubTotalPosition;
+    /** Height of the sub total area */
+    height?: Measure$1;
+}
+declare class SubTotal extends BranchDocumentElement<SubTotalProperties> {
+    constructor(content?: Content, props?: SubTotalProperties);
+    toDocFrame(): Proto.Node;
+}
+
 interface SpanProperties {
     bold?: boolean;
     italic?: boolean;
     underline?: boolean;
     strikethrough?: boolean;
+    color?: Color;
+    subscript?: boolean;
+    superscript?: boolean;
 }
 declare class Span extends BranchDocumentElement<SpanProperties> {
     constructor(content?: Content, props?: SpanProperties);
@@ -142,6 +232,82 @@ declare class SpaceVertically extends DocumentElement {
     toDocFrame(): Proto.Node;
 }
 
+interface SelectionEntryProperties {
+    /** UUID */
+    uuid?: string;
+    /** Internal name for the selection entry */
+    internalName?: string;
+    /** Display name */
+    name?: string;
+    /** Whether this entry is selected */
+    selected?: boolean;
+}
+declare class SelectionEntry extends BranchDocumentElement<SelectionEntryProperties> {
+    constructor(content?: Content, props?: SelectionEntryProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface SelectionProperties {
+    /** UUID */
+    uuid?: string;
+    /** Internal name for the selection */
+    internalName?: string;
+    /** Display name */
+    name?: string;
+    /** Whether multiple entries can be selected */
+    multi?: boolean;
+    /** Minimum number of selections required */
+    min?: number;
+    /** Maximum number of selections allowed */
+    max?: number;
+}
+declare class Selection extends BranchDocumentElement<SelectionProperties> {
+    constructor(content?: Content, props?: SelectionProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface SectionProperties {
+    uuid?: string;
+    /** UUID of the column definition to apply to this section */
+    cDefUuid?: string;
+}
+declare class Section extends BranchDocumentElement<SectionProperties> {
+    constructor(content?: Content, props?: SectionProperties);
+    toDocFrame(): Proto.Node;
+}
+
+type RuleStyle = "solid" | "sparse-shading" | "medium-shading" | "dense-shading" | "light-dotted" | "medium-dotted" | "heavy-dotted" | "light-dashed" | "medium-dashed" | "heavy-dashed" | "dash-pattern" | "double";
+type RuleMode = "normal" | "boundary";
+interface RuleBoundaries {
+    start?: Measure$1;
+    end?: Measure$1;
+}
+interface RuleProperties {
+    /** Horizontal offset */
+    xOffset?: Measure$1;
+    /** Vertical offset */
+    yOffset?: Measure$1;
+    /** Width of the rule */
+    width?: Measure$1;
+    /** Thickness of the rule line */
+    thickness?: Measure$1;
+    /** Rotation in degrees */
+    rotation?: number;
+    /** Rule color */
+    color?: Color;
+    /** Rule style (solid, dashed, dotted, etc.) */
+    style?: RuleStyle;
+    /** Rule mode */
+    mode?: RuleMode;
+    /** Rule boundaries for boundary mode */
+    boundaries?: RuleBoundaries;
+}
+declare class Rule extends DocumentElement {
+    props: RuleProperties;
+    constructor(props: RuleProperties);
+    toDocFrame(): Proto.Node;
+}
+
 declare class Font {
     private name;
     constructor(name: string);
@@ -187,15 +353,143 @@ declare class PageDefinition {
     toDocFrame(): Proto.ProtoPDef;
 }
 
+interface PageConditionProperties {
+    /** UUID */
+    uuid?: string;
+    /** Code expression to evaluate per page */
+    code?: string;
+}
+declare class PageCondition extends BranchDocumentElement<PageConditionProperties> {
+    constructor(content?: Content, props?: PageConditionProperties);
+    toDocFrame(): Proto.Node;
+}
+
 declare class Pagebreak extends DocumentElement {
     toDocFrame(): Proto.Node;
 }
 
+interface LoopEntryProperties {
+    /** Data path for this loop entry */
+    path?: string;
+    /** Index of this entry in the loop */
+    index?: number;
+    /** UUID */
+    uuid?: string;
+}
+declare class LoopEntry extends BranchDocumentElement<LoopEntryProperties> {
+    constructor(content?: Content, props?: LoopEntryProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface LoopProperties {
+    /** Data path to iterate over */
+    path?: string;
+    /** UUID */
+    uuid?: string;
+}
+declare class Loop extends BranchDocumentElement<LoopProperties> {
+    constructor(content?: Content, props?: LoopProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface LinkProperties {
+    /** The URL to link to */
+    url: string;
+}
+declare class Link extends BranchDocumentElement<LinkProperties> {
+    constructor(content?: Content, url?: string);
+    toDocFrame(): Proto.Node;
+}
+
 declare class Linebreak extends DocumentElement {
     toDocFrame(): Proto.Node;
 }
 
-declare class Header extends BranchDocumentElement<never> {
+interface IndentationProperties {
+    /** Left indentation */
+    left?: Measure$1;
+    /** Right indentation */
+    right?: Measure$1;
+    /** UUID */
+    uuid?: string;
+}
+declare class Indentation extends BranchDocumentElement<IndentationProperties> {
+    constructor(content?: Content, props?: IndentationProperties);
+    toDocFrame(): Proto.Node;
+}
+
+/**
+ * A ReferencePoint is used for elements like barcodes to specify the reference point
+ * of an object.
+ * Example:
+ * When specified reference point "top-left", the top-left point of a barcode is positioned
+ * relative to the top-left edge of the current line or page.
+ */
+type ReferencePoint = "top-left" | "top-right" | "center" | "bottom-left" | "bottom-right";
+
+type ImageScaleType = "relative" | "absolute" | "relative-to-column";
+interface FlipSettings {
+    x?: boolean;
+    y?: boolean;
+}
+interface CropSettings {
+    x?: Measure$1;
+    y?: Measure$1;
+    width?: Measure$1;
+    height?: Measure$1;
+}
+interface ImageProperties {
+    /** Alternative text for accessibility */
+    alt?: string;
+    /** Image name */
+    name?: string;
+    /** Image source URL or path */
+    src?: string;
+    /** Image filename */
+    filename?: string;
+    /** Scale factor (e.g. 1.0 = 100%) */
+    scale?: number;
+    /** Scale relative to column width (e.g. 0.5 = 50% of column) */
+    columnScale?: number;
+    /** Image width */
+    width?: Measure$1;
+    /** Image height */
+    height?: Measure$1;
+    /** X position */
+    x?: Measure$1;
+    /** Y position */
+    y?: Measure$1;
+    /** Whether the image is positioned absolutely */
+    positionAbsolute?: boolean;
+    /** Rotation in degrees */
+    rotation?: number;
+    /** Flip settings */
+    flip?: FlipSettings;
+    /** Crop settings */
+    crop?: CropSettings;
+    /** Reference point for positioning */
+    referencePoint?: ReferencePoint;
+    /** Hyperlink URL */
+    hyperlink?: string;
+    /** Scale type */
+    scaleType?: ImageScaleType;
+    /** UUID */
+    uuid?: string;
+    /** Inline image content as base64-encoded string */
+    imageContent?: string;
+}
+declare class Image extends DocumentElement {
+    props: ImageProperties;
+    constructor(props: ImageProperties);
+    toDocFrame(): Proto.Node;
+}
+
+type HeaderMode = "append-initial" | "append" | "extend" | "replace";
+interface HeaderProperties {
+    mode?: HeaderMode;
+}
+declare class Header extends BranchDocumentElement<HeaderProperties> {
+    constructor(content?: Content, props?: HeaderProperties);
     toDocFrame(): Proto.Node;
 }
 
@@ -208,7 +502,12 @@ declare class Formatted extends DocumentElement {
     toDocFrame(): Proto.Node;
 }
 
-declare class Footer extends BranchDocumentElement {
+type FooterMode = "append-initial" | "append" | "extend" | "replace";
+interface FooterProperties {
+    mode?: FooterMode;
+}
+declare class Footer extends BranchDocumentElement<FooterProperties> {
+    constructor(content?: Content, props?: FooterProperties);
     toDocFrame(): Proto.Node;
 }
 
@@ -294,18 +593,40 @@ declare class Document extends BranchDocumentElement<DocumentProperties> {
     toDocFrame(): Proto.Node;
 }
 
-declare class Directory extends BranchDocumentElement {
+type SemanticType = "none" | "part" | "art" | "sect" | "div";
+interface DirectoryProperties {
+    name?: string;
+    editable?: boolean;
+    semanticType?: SemanticType;
+}
+declare class Directory extends BranchDocumentElement<DirectoryProperties> {
+    constructor(content?: Content, props?: DirectoryProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface ConditionProperties {
+    /** UUID */
+    uuid?: string;
+    /** Code expression to evaluate */
+    code?: string;
+    /** Pre-evaluated result */
+    result?: boolean;
+    /** Whether the condition should be re-evaluated on regeneration */
+    regenerate?: boolean;
+}
+declare class Condition extends BranchDocumentElement<ConditionProperties> {
+    constructor(content?: Content, props?: ConditionProperties);
     toDocFrame(): Proto.Node;
 }
 
 /**
- * A ReferencePoint is used for elements like barcodes to specify the reference point
- * of an object.
- * Example:
- * When specified reference point "top-left", the top-left point of a barcode is positioned
- * relative to the top-left edge of the current line or page.
+ * CarryOver defines content that is carried over to the next page
+ * when a table or other element breaks across pages.
  */
-type ReferencePoint = "top-left" | "top-right" | "center" | "bottom-left" | "bottom-right";
+declare class CarryOver extends BranchDocumentElement {
+    constructor(content?: Content);
+    toDocFrame(): Proto.Node;
+}
 
 interface BarcodeProperties {
     type: Proto.ProtoBarcodeType;
@@ -320,6 +641,10 @@ interface BarcodeProperties {
     height: AbsoluteMeasure;
     data: string;
     positionAbsolute: boolean;
+    padding?: AbsoluteMeasure;
+    code?: string;
+    altText?: string;
+    uuid?: string;
 }
 declare class Barcode extends DocumentElement {
     props: BarcodeProperties;
@@ -327,6 +652,41 @@ declare class Barcode extends DocumentElement {
     toDocFrame(): Proto.Node;
 }
 
+type TextFlowType = "around" | "no-flow" | "foreground" | "background";
+interface AdvancedIllustrationAreaProperties {
+    /** UUID */
+    uuid?: string;
+    /** Whether the AIA is absolutely positioned */
+    absolute?: boolean;
+    /** Width */
+    width?: Measure$1;
+    /** Height */
+    height?: Measure$1;
+    /** X position */
+    x?: Measure$1;
+    /** Y position */
+    y?: Measure$1;
+    /** How text flows around the AIA */
+    textFlow?: TextFlowType;
+    /** Rotation in degrees */
+    rotation?: number;
+}
+declare class AdvancedIllustrationArea extends BranchDocumentElement<AdvancedIllustrationAreaProperties> {
+    constructor(content?: Content, props?: AdvancedIllustrationAreaProperties);
+    toDocFrame(): Proto.Node;
+}
+
+interface AdjustHorizontallyProperties {
+    /** Minimum font size for horizontal adjustment */
+    minFontSize?: Measure$1;
+    /** Maximum font size for horizontal adjustment */
+    maxFontSize?: Measure$1;
+}
+declare class AdjustHorizontally extends BranchDocumentElement<AdjustHorizontallyProperties> {
+    constructor(content?: Content, props?: AdjustHorizontallyProperties);
+    toDocFrame(): Proto.Node;
+}
+
 declare class Connection {
     url: string;
     token: string;
@@ -336,6 +696,7 @@ declare class Connection {
 }
 
 declare const _default: {
+    Alignment: typeof Alignment;
     Border: {
         Border: typeof Border;
         SideBorders: typeof SideBorders;
@@ -346,24 +707,43 @@ declare const _default: {
     };
     Connection: typeof Connection;
     Content: {
+        AdjustHorizontally: typeof AdjustHorizontally;
+        AdvancedIllustrationArea: typeof AdvancedIllustrationArea;
         Barcode: typeof Barcode;
+        CarryOver: typeof CarryOver;
         ColumnDefinition: typeof ColumnDefinition;
         ColumnPosition: typeof ColumnPosition;
+        Condition: typeof Condition;
         Directory: typeof Directory;
         Document: typeof Document;
         Footer: typeof Footer;
         Formatted: typeof Formatted;
         Header: typeof Header;
+        Image: typeof Image;
+        Indentation: typeof Indentation;
         Linebreak: typeof Linebreak;
+        Link: typeof Link;
+        Loop: typeof Loop;
+        LoopEntry: typeof LoopEntry;
         Pagebreak: typeof Pagebreak;
+        PageCondition: typeof PageCondition;
         PageDefinition: typeof PageDefinition;
         Paragraph: typeof Paragraph;
+        Rule: typeof Rule;
+        Section: typeof Section;
+        Selection: typeof Selection;
+        SelectionEntry: typeof SelectionEntry;
         SpaceVertically: typeof SpaceVertically;
         Span: typeof Span;
+        SubTotal: typeof SubTotal;
         Table: typeof Table;
         TableCell: typeof TableCell;
+        TableContentGroup: typeof TableContentGroup;
         TableRow: typeof TableRow;
+        Tag: typeof Tag;
         Text: typeof Text;
+        Variable: typeof Variable;
+        WsArea: typeof WsArea;
     };
     Font: {
         Font: typeof Font;