@reportwright/engine 0.0.0-stage → 0.11.0

package/dist/types/src/engine/schema/report.schema.d.ts

@@ -0,0 +1,2421 @@
+export namespace REPORT_SCHEMA {
+    let $schema: string;
+    let $id: string;
+    let title: string;
+    let $ref: string;
+    namespace $defs {
+        let Expr: {
+            "x-ts-decl": string;
+            description: string;
+        };
+        namespace Style {
+            let type: string;
+            namespace properties {
+                namespace fontFamily {
+                    let type_1: string;
+                    export { type_1 as type };
+                }
+                let fontSize: {
+                    "x-ts": string;
+                };
+                let fontWeight: {
+                    "x-ts": string;
+                };
+                let fontStyle: {
+                    "x-ts": string;
+                };
+                namespace color {
+                    let type_2: string;
+                    export { type_2 as type };
+                }
+                namespace backgroundColor {
+                    let type_3: string;
+                    export { type_3 as type };
+                }
+                namespace backgroundImage {
+                    let type_4: string;
+                    export { type_4 as type };
+                }
+                let backgroundFit: {
+                    "x-ts": string;
+                };
+                let textAlign: {
+                    "x-ts": string;
+                };
+                let verticalAlign: {
+                    "x-ts": string;
+                };
+                namespace textDecoration {
+                    let type_5: string;
+                    export { type_5 as type };
+                }
+                let lineHeight: {
+                    "x-ts": string;
+                };
+                let padding: {
+                    "x-ts": string;
+                };
+                namespace border {
+                    let type_6: string;
+                    export { type_6 as type };
+                }
+                namespace borderTop {
+                    let type_7: string;
+                    export { type_7 as type };
+                }
+                namespace borderRight {
+                    let type_8: string;
+                    export { type_8 as type };
+                }
+                namespace borderBottom {
+                    let type_9: string;
+                    export { type_9 as type };
+                }
+                namespace borderLeft {
+                    let type_10: string;
+                    export { type_10 as type };
+                }
+                namespace format {
+                    let type_11: string;
+                    export { type_11 as type };
+                }
+                namespace writingMode {
+                    let type_12: string;
+                    export { type_12 as type };
+                }
+                namespace stroke {
+                    let type_13: string;
+                    export { type_13 as type };
+                }
+                let strokeWidth: {
+                    "x-ts": string;
+                };
+                namespace strokeDash {
+                    let type_14: string;
+                    export { type_14 as type };
+                }
+                namespace fill {
+                    let type_15: string;
+                    export { type_15 as type };
+                }
+                let radius: {
+                    "x-ts": string;
+                };
+            }
+            let additionalProperties: boolean;
+            let description: string;
+        }
+        namespace Action {
+            let description_1: string;
+            export { description_1 as description };
+            export let anyOf: ({
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    url?: undefined;
+                    report?: undefined;
+                    params?: undefined;
+                    target?: undefined;
+                    toggle?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    url: {
+                        "x-ts": string;
+                    };
+                    report?: undefined;
+                    params?: undefined;
+                    target?: undefined;
+                    toggle?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    report: {
+                        "x-ts": string;
+                    };
+                    params: {
+                        "x-ts": string;
+                        type: string;
+                    };
+                    url?: undefined;
+                    target?: undefined;
+                    toggle?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    target: {
+                        "x-ts": string;
+                    };
+                    url?: undefined;
+                    report?: undefined;
+                    params?: undefined;
+                    toggle?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    params: {
+                        "x-ts": string;
+                        type: string;
+                    };
+                    toggle: {
+                        type: string;
+                    };
+                    url?: undefined;
+                    report?: undefined;
+                    target?: undefined;
+                };
+                required: string[];
+            })[];
+        }
+        let ItemBase: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                name: {
+                    type: string;
+                };
+                x: {
+                    type: string;
+                };
+                y: {
+                    type: string;
+                };
+                w: {
+                    type: string;
+                };
+                h: {
+                    type: string;
+                };
+                style: {
+                    $ref: string;
+                };
+                styleName: {
+                    type: string;
+                };
+                hidden: {
+                    "x-ts": string;
+                };
+                dataSet: {
+                    "x-ts": string;
+                };
+                alt: {
+                    type: string;
+                    description: string;
+                };
+                keepTogether: {
+                    type: string;
+                };
+                pageBreakBefore: {
+                    type: string;
+                };
+                pageBreakAfter: {
+                    type: string;
+                };
+                bookmark: {
+                    "x-ts": string;
+                };
+                tooltip: {
+                    "x-ts": string;
+                };
+                action: {
+                    $ref: string;
+                };
+            };
+            required: string[];
+            "x-internal": boolean;
+        };
+        namespace TextBox {
+            let allOf: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    canGrow: {
+                        type: string;
+                    };
+                    canShrink: {
+                        type: string;
+                    };
+                    shrinkToFit: {
+                        type: string;
+                    };
+                    minFontSize: {
+                        type: string;
+                    };
+                    shrinkStep: {
+                        type: string;
+                    };
+                    rotate: {
+                        type: string;
+                    };
+                    headingLevel: {
+                        "x-ts": string;
+                        enum: (string | number)[];
+                        description: string;
+                    };
+                    dir: {
+                        enum: string[];
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+        }
+        namespace RichText {
+            let allOf_1: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        type: string;
+                    };
+                    htmlFromData: {
+                        type: string;
+                    };
+                    canGrow: {
+                        type: string;
+                    };
+                    canShrink: {
+                        type: string;
+                    };
+                    listIndent: {
+                        type: string;
+                    };
+                    paragraphSpacing: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_1 as allOf };
+        }
+        namespace Image {
+            let allOf_2: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    src: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                    fit: {
+                        enum: string[];
+                    };
+                    autoSize: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_2 as allOf };
+        }
+        namespace Line {
+            let allOf_3: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    direction: {
+                        enum: string[];
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_3 as allOf };
+        }
+        namespace Shape {
+            let allOf_4: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    shape: {
+                        enum: string[];
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_4 as allOf };
+        }
+        namespace SortSpec {
+            let type_16: string;
+            export { type_16 as type };
+            let description_2: string;
+            export { description_2 as description };
+            export namespace properties_1 {
+                let by: {
+                    "x-ts": string;
+                    description: string;
+                };
+                namespace dir {
+                    let _enum: string[];
+                    export { _enum as enum };
+                    let description_3: string;
+                    export { description_3 as description };
+                }
+            }
+            export { properties_1 as properties };
+            export let required: string[];
+            let additionalProperties_1: boolean;
+            export { additionalProperties_1 as additionalProperties };
+        }
+        namespace TableCell {
+            let type_17: string;
+            export { type_17 as type };
+            export namespace properties_2 {
+                let value: {
+                    "x-ts": string;
+                };
+                let sortBy: {
+                    "x-ts": string;
+                    description: string;
+                };
+                namespace style {
+                    let $ref_1: string;
+                    export { $ref_1 as $ref };
+                }
+                namespace colSpan {
+                    let type_18: string;
+                    export { type_18 as type };
+                    let description_4: string;
+                    export { description_4 as description };
+                }
+                namespace rowSpan {
+                    let type_19: string;
+                    export { type_19 as type };
+                    let description_5: string;
+                    export { description_5 as description };
+                }
+                namespace item {
+                    let $ref_2: string;
+                    export { $ref_2 as $ref };
+                    let description_6: string;
+                    export { description_6 as description };
+                }
+                namespace action {
+                    let $ref_3: string;
+                    export { $ref_3 as $ref };
+                }
+            }
+            export { properties_2 as properties };
+            let additionalProperties_2: boolean;
+            export { additionalProperties_2 as additionalProperties };
+        }
+        namespace TableRow {
+            let type_20: string;
+            export { type_20 as type };
+            export namespace properties_3 {
+                export namespace cells {
+                    let type_21: string;
+                    export { type_21 as type };
+                    export let items: {
+                        "x-ts": string;
+                        anyOf: ({
+                            $ref: string;
+                            type?: undefined;
+                        } | {
+                            type: string;
+                            $ref?: undefined;
+                        })[];
+                    };
+                }
+                export namespace height {
+                    let type_22: string;
+                    export { type_22 as type };
+                }
+                export namespace style_1 {
+                    let $ref_4: string;
+                    export { $ref_4 as $ref };
+                }
+                export { style_1 as style };
+            }
+            export { properties_3 as properties };
+            let required_1: string[];
+            export { required_1 as required };
+            let additionalProperties_3: boolean;
+            export { additionalProperties_3 as additionalProperties };
+        }
+        namespace TableGroup {
+            let type_23: string;
+            export { type_23 as type };
+            export namespace properties_4 {
+                export namespace expr {
+                    let type_24: string;
+                    export { type_24 as type };
+                }
+                export namespace name {
+                    let type_25: string;
+                    export { type_25 as type };
+                }
+                export namespace header {
+                    let type_26: string;
+                    export { type_26 as type };
+                    export namespace items_1 {
+                        let $ref_5: string;
+                        export { $ref_5 as $ref };
+                    }
+                    export { items_1 as items };
+                }
+                export namespace footer {
+                    let type_27: string;
+                    export { type_27 as type };
+                    export namespace items_2 {
+                        let $ref_6: string;
+                        export { $ref_6 as $ref };
+                    }
+                    export { items_2 as items };
+                }
+                export namespace sort {
+                    let _enum_1: string[];
+                    export { _enum_1 as enum };
+                    let description_7: string;
+                    export { description_7 as description };
+                }
+                let sortBy_1: {
+                    "x-ts": string;
+                    description: string;
+                };
+                export { sortBy_1 as sortBy };
+                export namespace pageBreak {
+                    let type_28: string;
+                    export { type_28 as type };
+                }
+                export namespace collapsible {
+                    let type_29: string;
+                    export { type_29 as type };
+                }
+                export namespace initiallyCollapsed {
+                    let type_30: string;
+                    export { type_30 as type };
+                }
+                export let parent: {
+                    "x-ts": string;
+                    description: string;
+                };
+                export namespace indent {
+                    let type_31: string;
+                    export { type_31 as type };
+                }
+                export namespace expandLevels {
+                    let type_32: string;
+                    export { type_32 as type };
+                }
+                export namespace newSection {
+                    let type_33: string;
+                    export { type_33 as type };
+                    let description_8: string;
+                    export { description_8 as description };
+                }
+            }
+            export { properties_4 as properties };
+            let required_2: string[];
+            export { required_2 as required };
+            let additionalProperties_4: boolean;
+            export { additionalProperties_4 as additionalProperties };
+        }
+        namespace Table {
+            let allOf_5: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    columns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                width: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    header: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    groups: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    detail: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    footer: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    repeatHeader: {
+                        type: string;
+                    };
+                    widowControl: {
+                        type: string;
+                        description: string;
+                    };
+                    fitColumns: {
+                        type: string;
+                        description: string;
+                    };
+                    noRowsText: {
+                        type: string;
+                    };
+                    sort: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        description: string;
+                    };
+                    filters: {
+                        type: string;
+                        items: {};
+                    };
+                    printAtBottom: {
+                        type: string;
+                        description: string;
+                    };
+                    overflow: {
+                        enum: string[];
+                        description: string;
+                    };
+                    repeatColumns: {
+                        type: string;
+                    };
+                    pageOrder: {
+                        enum: string[];
+                    };
+                    overflowTo: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_5 as allOf };
+        }
+        namespace Container {
+            let allOf_6: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    items: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_6 as allOf };
+        }
+        namespace List {
+            let allOf_7: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    items: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    groupBy: {
+                        "x-ts": string;
+                    };
+                    pageBreakBetween: {
+                        type: string;
+                    };
+                    sort: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        description: string;
+                    };
+                    filters: {
+                        type: string;
+                        items: {};
+                    };
+                    columns: {
+                        type: string;
+                        description: string;
+                    };
+                    columnGap: {
+                        type: string;
+                    };
+                    newSection: {
+                        type: string;
+                    };
+                    groupAdjacent: {
+                        type: string;
+                        description: string;
+                    };
+                    inheritRows: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_7 as allOf };
+        }
+        namespace CheckBox {
+            let allOf_8: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    text: {
+                        "x-ts": string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_8 as allOf };
+        }
+        namespace ChartAxis {
+            let type_34: string;
+            export { type_34 as type };
+            export namespace properties_5 {
+                export namespace title_1 {
+                    let type_35: string;
+                    export { type_35 as type };
+                }
+                export { title_1 as title };
+                export namespace format_1 {
+                    let type_36: string;
+                    export { type_36 as type };
+                }
+                export { format_1 as format };
+                export namespace min {
+                    let type_37: string;
+                    export { type_37 as type };
+                }
+                export namespace max {
+                    let type_38: string;
+                    export { type_38 as type };
+                }
+                export namespace log {
+                    let type_39: string;
+                    export { type_39 as type };
+                }
+                export namespace gridlines {
+                    let type_40: string;
+                    export { type_40 as type };
+                }
+                export namespace labelAngle {
+                    let type_41: string;
+                    export { type_41 as type };
+                    let description_9: string;
+                    export { description_9 as description };
+                }
+                export namespace reversed {
+                    let type_42: string;
+                    export { type_42 as type };
+                }
+            }
+            export { properties_5 as properties };
+        }
+        namespace ChartSeries {
+            let type_43: string;
+            export { type_43 as type };
+            export namespace properties_6 {
+                export namespace name_1 {
+                    let type_44: string;
+                    export { type_44 as type };
+                }
+                export { name_1 as name };
+                let value_1: {
+                    "x-ts": string;
+                };
+                export { value_1 as value };
+                export namespace color_1 {
+                    let type_45: string;
+                    export { type_45 as type };
+                }
+                export { color_1 as color };
+                export namespace type_46 {
+                    let _enum_2: string[];
+                    export { _enum_2 as enum };
+                    let description_10: string;
+                    export { description_10 as description };
+                }
+                export { type_46 as type };
+                export namespace axis {
+                    let _enum_3: string[];
+                    export { _enum_3 as enum };
+                }
+                export let low: {
+                    "x-ts": string;
+                    description: string;
+                };
+                export let high: {
+                    "x-ts": string;
+                };
+                export let open: {
+                    "x-ts": string;
+                };
+                export let close: {
+                    "x-ts": string;
+                };
+                export let size: {
+                    "x-ts": string;
+                    description: string;
+                };
+                export namespace line {
+                    let _enum_4: string[];
+                    export { _enum_4 as enum };
+                }
+            }
+            export { properties_6 as properties };
+            let additionalProperties_5: boolean;
+            export { additionalProperties_5 as additionalProperties };
+        }
+        namespace ChartOverlay {
+            let anyOf_1: ({
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    kind: {
+                        enum: string[];
+                    };
+                    order: {
+                        type: string;
+                    };
+                    series: {
+                        type: string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    period?: undefined;
+                    value?: undefined;
+                    axis?: undefined;
+                    showValue?: undefined;
+                    from?: undefined;
+                    to?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    period: {
+                        type: string;
+                    };
+                    series: {
+                        type: string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    kind?: undefined;
+                    order?: undefined;
+                    value?: undefined;
+                    axis?: undefined;
+                    showValue?: undefined;
+                    from?: undefined;
+                    to?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    axis: {
+                        enum: string[];
+                    };
+                    color: {
+                        type: string;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    showValue: {
+                        type: string;
+                    };
+                    kind?: undefined;
+                    order?: undefined;
+                    series?: undefined;
+                    period?: undefined;
+                    from?: undefined;
+                    to?: undefined;
+                };
+                required: string[];
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    from: {
+                        "x-ts": string;
+                    };
+                    to: {
+                        "x-ts": string;
+                    };
+                    axis: {
+                        enum: string[];
+                    };
+                    color: {
+                        type: string;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    kind?: undefined;
+                    order?: undefined;
+                    series?: undefined;
+                    period?: undefined;
+                    value?: undefined;
+                    showValue?: undefined;
+                };
+                required: string[];
+            })[];
+            export { anyOf_1 as anyOf };
+        }
+        namespace ChartPalette {
+            let _enum_5: string[];
+            export { _enum_5 as enum };
+        }
+        namespace Chart {
+            let allOf_9: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    chartType: {
+                        enum: string[];
+                    };
+                    title: {
+                        "x-ts": string;
+                    };
+                    category: {
+                        "x-ts": string;
+                    };
+                    categorySort: {
+                        enum: string[];
+                    };
+                    categoryFormat: {
+                        type: string;
+                    };
+                    series: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    seriesGroup: {
+                        "x-ts": string;
+                    };
+                    stacked: {
+                        "x-ts": string;
+                    };
+                    showValues: {
+                        type: string;
+                    };
+                    valueFormat: {
+                        type: string;
+                    };
+                    legend: {
+                        enum: string[];
+                    };
+                    xValue: {
+                        "x-ts": string;
+                    };
+                    pointAction: {
+                        $ref: string;
+                    };
+                    pointColor: {
+                        "x-ts": string;
+                    };
+                    tooltips: {
+                        type: string;
+                    };
+                    xTitle: {
+                        type: string;
+                    };
+                    fontSize: {
+                        type: string;
+                    };
+                    background: {
+                        type: string;
+                    };
+                    maxCategories: {
+                        type: string;
+                    };
+                    outliers: {
+                        enum: string[];
+                        description: string;
+                    };
+                    line: {
+                        enum: string[];
+                    };
+                    axes: {
+                        type: string;
+                        properties: {
+                            x: {
+                                $ref: string;
+                            };
+                            y: {
+                                $ref: string;
+                            };
+                            y2: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                    overlays: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    labelTemplate: {
+                        type: string;
+                        description: string;
+                    };
+                    labelPosition: {
+                        enum: string[];
+                    };
+                    palette: {
+                        "x-ts": string;
+                    };
+                    colorByCategory: {
+                        type: string;
+                        description: string;
+                    };
+                    animation: {
+                        enum: string[];
+                        description: string;
+                    };
+                    upColor: {
+                        type: string;
+                    };
+                    downColor: {
+                        type: string;
+                    };
+                    binCount: {
+                        type: string;
+                        description: string;
+                    };
+                    binWidth: {
+                        type: string;
+                        description: string;
+                    };
+                    showMean: {
+                        type: string;
+                        description: string;
+                    };
+                    waterfallTotals: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                    showTotal: {
+                        type: string;
+                        description: string;
+                    };
+                    totalLabel: {
+                        type: string;
+                        description: string;
+                    };
+                    totalColor: {
+                        type: string;
+                        description: string;
+                    };
+                    ganttStart: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                    ganttEnd: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                    ganttToday: {
+                        type: string;
+                        description: string;
+                    };
+                    todayColor: {
+                        type: string;
+                        description: string;
+                    };
+                    gaugeShape: {
+                        enum: string[];
+                        description: string;
+                    };
+                    gaugeIndicator: {
+                        enum: string[];
+                        description: string;
+                    };
+                    pointerColor: {
+                        type: string;
+                        description: string;
+                    };
+                    gaugeTicks: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_9 as allOf };
+        }
+        namespace FormField {
+            let allOf_10: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    kind: {
+                        enum: string[];
+                    };
+                    fieldName: {
+                        "x-ts": string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    options: {
+                        "x-ts": string;
+                    };
+                    required: {
+                        type: string;
+                    };
+                    readOnly: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_10 as allOf };
+        }
+        namespace MapItem {
+            let allOf_11: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    geojson: {
+                        type: string;
+                    };
+                    geometry: {
+                        "x-ts": string;
+                    };
+                    shapeKey: {
+                        "x-ts": string;
+                    };
+                    valueDataSet: {
+                        type: string;
+                    };
+                    valueKey: {
+                        "x-ts": string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    valueFormat: {
+                        type: string;
+                    };
+                    colorLow: {
+                        type: string;
+                    };
+                    colorHigh: {
+                        type: string;
+                    };
+                    legend: {
+                        enum: string[];
+                    };
+                    pointDataSet: {
+                        type: string;
+                    };
+                    lat: {
+                        "x-ts": string;
+                    };
+                    lon: {
+                        "x-ts": string;
+                    };
+                    pointSize: {
+                        "x-ts": string;
+                    };
+                    pointLabel: {
+                        "x-ts": string;
+                    };
+                    pointColor: {
+                        type: string;
+                    };
+                    colorScale: {
+                        enum: string[];
+                        description: string;
+                    };
+                    classes: {
+                        type: string;
+                        description: string;
+                    };
+                    lineColor: {
+                        type: string;
+                        description: string;
+                    };
+                    lineWidth: {
+                        type: string;
+                        description: string;
+                    };
+                    regionAction: {
+                        $ref: string;
+                        description: string;
+                    };
+                    tooltips: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_11 as allOf };
+        }
+        namespace Sparkline {
+            let allOf_12: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    category: {
+                        "x-ts": string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    style: {
+                        "x-ts": string;
+                        enum: string[];
+                    };
+                    bandLow: {
+                        "x-ts": string;
+                    };
+                    bandHigh: {
+                        "x-ts": string;
+                    };
+                    bandColor: {
+                        type: string;
+                    };
+                    negColor: {
+                        type: string;
+                    };
+                    negativeColor: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_12 as allOf };
+        }
+        namespace DataBar {
+            let allOf_13: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    max: {
+                        "x-ts": string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                    negativeColor: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_13 as allOf };
+        }
+        namespace Bullet {
+            let allOf_14: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    max: {
+                        "x-ts": string;
+                    };
+                    target: {
+                        "x-ts": string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_14 as allOf };
+        }
+        namespace IconSet {
+            let allOf_15: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    iconSet: {
+                        enum: string[];
+                    };
+                    lower: {
+                        "x-ts": string;
+                    };
+                    upper: {
+                        "x-ts": string;
+                    };
+                    reverse: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_15 as allOf };
+        }
+        namespace RangeBar {
+            let allOf_16: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    low: {
+                        "x-ts": string;
+                    };
+                    high: {
+                        "x-ts": string;
+                    };
+                    min: {
+                        "x-ts": string;
+                    };
+                    max: {
+                        "x-ts": string;
+                    };
+                    color: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_16 as allOf };
+        }
+        namespace Barcode {
+            let allOf_17: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    symbology: {
+                        type: string;
+                        description: string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    showText: {
+                        type: string;
+                    };
+                    captionPosition: {
+                        enum: string[];
+                    };
+                    quietZone: {
+                        type: string;
+                        description: string;
+                    };
+                    rotate: {
+                        "x-ts": string;
+                        enum: (string | number)[];
+                    };
+                    qrErrorLevel: {
+                        enum: string[];
+                    };
+                    qrVersion: {
+                        type: string;
+                    };
+                    qrMask: {
+                        type: string;
+                    };
+                    dmShape: {
+                        enum: string[];
+                    };
+                    dmSize: {
+                        type: string;
+                    };
+                    pdfColumns: {
+                        type: string;
+                    };
+                    pdfRows: {
+                        type: string;
+                    };
+                    pdfErrorLevel: {
+                        type: string;
+                    };
+                    pdfCompact: {
+                        type: string;
+                    };
+                    aztecLayers: {
+                        type: string;
+                    };
+                    aztecErrorPercent: {
+                        type: string;
+                    };
+                    maxiMode: {
+                        type: string;
+                    };
+                    checkDigit: {
+                        type: string;
+                    };
+                    barRatio: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_17 as allOf };
+        }
+        namespace PivotGroup {
+            let type_47: string;
+            export { type_47 as type };
+            export namespace properties_7 {
+                let expr_1: {
+                    "x-ts": string;
+                };
+                export { expr_1 as expr };
+                export namespace name_2 {
+                    let type_48: string;
+                    export { type_48 as type };
+                }
+                export { name_2 as name };
+                export let label: {
+                    "x-ts": string;
+                };
+                export namespace format_2 {
+                    let type_49: string;
+                    export { type_49 as type };
+                }
+                export { format_2 as format };
+                export namespace sort_1 {
+                    let _enum_6: string[];
+                    export { _enum_6 as enum };
+                }
+                export { sort_1 as sort };
+                let sortBy_2: {
+                    "x-ts": string;
+                };
+                export { sortBy_2 as sortBy };
+                export namespace total {
+                    let _enum_7: string[];
+                    export { _enum_7 as enum };
+                    let description_11: string;
+                    export { description_11 as description };
+                }
+                export namespace totalLabel {
+                    let type_50: string;
+                    export { type_50 as type };
+                }
+                export namespace collapsible_1 {
+                    let type_51: string;
+                    export { type_51 as type };
+                }
+                export { collapsible_1 as collapsible };
+                export namespace initiallyCollapsed_1 {
+                    let type_52: string;
+                    export { type_52 as type };
+                }
+                export { initiallyCollapsed_1 as initiallyCollapsed };
+                export namespace width {
+                    let type_53: string;
+                    export { type_53 as type };
+                    let description_12: string;
+                    export { description_12 as description };
+                }
+                export namespace header_1 {
+                    let type_54: string;
+                    export { type_54 as type };
+                }
+                export { header_1 as header };
+                export namespace style_2 {
+                    let $ref_7: string;
+                    export { $ref_7 as $ref };
+                }
+                export { style_2 as style };
+            }
+            export { properties_7 as properties };
+            let required_3: string[];
+            export { required_3 as required };
+        }
+        namespace PivotValue {
+            let type_55: string;
+            export { type_55 as type };
+            export namespace properties_8 {
+                let value_2: {
+                    "x-ts": string;
+                };
+                export { value_2 as value };
+                export namespace name_3 {
+                    let type_56: string;
+                    export { type_56 as type };
+                }
+                export { name_3 as name };
+                export namespace label_1 {
+                    let type_57: string;
+                    export { type_57 as type };
+                }
+                export { label_1 as label };
+                export namespace format_3 {
+                    let type_58: string;
+                    export { type_58 as type };
+                }
+                export { format_3 as format };
+                export namespace show {
+                    let _enum_8: string[];
+                    export { _enum_8 as enum };
+                }
+                export namespace width_1 {
+                    let type_59: string;
+                    export { type_59 as type };
+                }
+                export { width_1 as width };
+                export namespace style_3 {
+                    let $ref_8: string;
+                    export { $ref_8 as $ref };
+                }
+                export { style_3 as style };
+            }
+            export { properties_8 as properties };
+            let required_4: string[];
+            export { required_4 as required };
+        }
+        namespace Matrix {
+            let allOf_18: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    rowGroups: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        description: string;
+                    };
+                    columnGroups: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    values: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    overflow: {
+                        enum: string[];
+                    };
+                    pageOrder: {
+                        enum: string[];
+                    };
+                    rowGroup: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                    columnGroup: {
+                        "x-ts": string;
+                    };
+                    value: {
+                        "x-ts": string;
+                    };
+                    valueFormat: {
+                        type: string;
+                    };
+                    rowSort: {
+                        enum: string[];
+                    };
+                    columnSort: {
+                        enum: string[];
+                    };
+                    rowTotals: {
+                        type: string;
+                    };
+                    columnTotals: {
+                        type: string;
+                    };
+                    corner: {
+                        type: string;
+                    };
+                    rowHeaderWidth: {
+                        type: string;
+                    };
+                    columnWidth: {
+                        type: string;
+                    };
+                    repeatHeader: {
+                        type: string;
+                    };
+                    headerStyle: {
+                        $ref: string;
+                    };
+                    cellStyle: {
+                        $ref: string;
+                    };
+                    totalStyle: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_18 as allOf };
+        }
+        namespace Subreport {
+            let allOf_19: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    report: {
+                        type: string;
+                    };
+                    params: {
+                        "x-ts": string;
+                        type: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_19 as allOf };
+        }
+        namespace TableOfContents {
+            let allOf_20: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+                required?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    title: {
+                        type: string;
+                    };
+                    levels: {
+                        type: string;
+                    };
+                    source: {
+                        enum: string[];
+                        description: string;
+                    };
+                    numbering: {
+                        "x-ts": string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                $ref?: undefined;
+            })[];
+            export { allOf_20 as allOf };
+        }
+        namespace Item {
+            let anyOf_2: {
+                $ref: string;
+            }[];
+            export { anyOf_2 as anyOf };
+        }
+        let ItemType: {
+            "x-ts-decl": string;
+        };
+        namespace Band {
+            let type_60: string;
+            export { type_60 as type };
+            export namespace properties_9 {
+                export namespace height_1 {
+                    let type_61: string;
+                    export { type_61 as type };
+                }
+                export { height_1 as height };
+                export namespace items_3 {
+                    let type_62: string;
+                    export { type_62 as type };
+                    export namespace items_4 {
+                        let $ref_9: string;
+                        export { $ref_9 as $ref };
+                    }
+                    export { items_4 as items };
+                }
+                export { items_3 as items };
+                export namespace printOnFirstPage {
+                    let type_63: string;
+                    export { type_63 as type };
+                }
+                export namespace printOnLastPage {
+                    let type_64: string;
+                    export { type_64 as type };
+                }
+                export namespace columns {
+                    let type_65: string;
+                    export { type_65 as type };
+                    export namespace properties_10 {
+                        namespace count {
+                            let type_66: string;
+                            export { type_66 as type };
+                        }
+                        namespace gap {
+                            let type_67: string;
+                            export { type_67 as type };
+                        }
+                    }
+                    export { properties_10 as properties };
+                    let required_5: string[];
+                    export { required_5 as required };
+                }
+            }
+            export { properties_9 as properties };
+            let required_6: string[];
+            export { required_6 as required };
+        }
+        namespace BodySection {
+            let description_13: string;
+            export { description_13 as description };
+            let allOf_21: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    page: {
+                        "x-ts": string;
+                        type: string;
+                    };
+                };
+                $ref?: undefined;
+            })[];
+            export { allOf_21 as allOf };
+        }
+        namespace Field {
+            let type_68: string;
+            export { type_68 as type };
+            export namespace properties_11 {
+                export namespace name_4 {
+                    let type_69: string;
+                    export { type_69 as type };
+                }
+                export { name_4 as name };
+                export namespace type_70 {
+                    let _enum_9: string[];
+                    export { _enum_9 as enum };
+                    let description_14: string;
+                    export { description_14 as description };
+                }
+                export { type_70 as type };
+                export namespace path {
+                    let type_71: string;
+                    export { type_71 as type };
+                }
+                export namespace expr_2 {
+                    let type_72: string;
+                    export { type_72 as type };
+                }
+                export { expr_2 as expr };
+            }
+            export { properties_11 as properties };
+            let required_7: string[];
+            export { required_7 as required };
+        }
+        namespace Parameter {
+            let type_73: string;
+            export { type_73 as type };
+            export namespace properties_12 {
+                export namespace name_5 {
+                    let type_74: string;
+                    export { type_74 as type };
+                }
+                export { name_5 as name };
+                export namespace type_75 {
+                    let _enum_10: string[];
+                    export { _enum_10 as enum };
+                }
+                export { type_75 as type };
+                export namespace prompt {
+                    let type_76: string;
+                    export { type_76 as type };
+                }
+                let _default: {};
+                export { _default as default };
+                export namespace required_8 {
+                    let type_77: string;
+                    export { type_77 as type };
+                }
+                export { required_8 as required };
+                export namespace multi {
+                    let type_78: string;
+                    export { type_78 as type };
+                }
+                export namespace hidden {
+                    let type_79: string;
+                    export { type_79 as type };
+                }
+                export namespace options {
+                    let type_80: string;
+                    export { type_80 as type };
+                    let items_5: {
+                        "x-ts": string;
+                    };
+                    export { items_5 as items };
+                }
+                export namespace optionsFrom {
+                    let type_81: string;
+                    export { type_81 as type };
+                    export namespace properties_13 {
+                        export namespace dataSet {
+                            let type_82: string;
+                            export { type_82 as type };
+                        }
+                        export namespace value_3 {
+                            let type_83: string;
+                            export { type_83 as type };
+                        }
+                        export { value_3 as value };
+                        export namespace label_2 {
+                            let type_84: string;
+                            export { type_84 as type };
+                        }
+                        export { label_2 as label };
+                    }
+                    export { properties_13 as properties };
+                    let required_9: string[];
+                    export { required_9 as required };
+                }
+                export namespace editor {
+                    let type_85: string;
+                    export { type_85 as type };
+                }
+            }
+            export { properties_12 as properties };
+            let required_10: string[];
+            export { required_10 as required };
+            let additionalProperties_6: boolean;
+            export { additionalProperties_6 as additionalProperties };
+        }
+        namespace DataSource {
+            let anyOf_3: ({
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    type: {
+                        const: string;
+                        enum?: undefined;
+                    };
+                    data: {
+                        type?: undefined;
+                    };
+                    url?: undefined;
+                    method?: undefined;
+                    headers?: undefined;
+                    query?: undefined;
+                    connection?: undefined;
+                };
+                required: string[];
+                additionalProperties?: undefined;
+            } | {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    type: {
+                        const: string;
+                        enum?: undefined;
+                    };
+                    data: {
+                        type: string;
+                    };
+                    url: {
+                        type: string;
+                    };
+                    method?: undefined;
+                    headers?: undefined;
+                    query?: undefined;
+                    connection?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    type: {
+                        enum: string[];
+                        const?: undefined;
+                    };
+                    url: {
+                        type: string;
+                    };
+                    method: {
+                        type: string;
+                    };
+                    headers: {
+                        "x-ts": string;
+                        type: string;
+                    };
+                    query: {
+                        type: string;
+                    };
+                    data?: undefined;
+                    connection?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    type: {
+                        const: string;
+                        enum?: undefined;
+                    };
+                    connection: {
+                        type: string;
+                    };
+                    query: {
+                        type: string;
+                    };
+                    data?: undefined;
+                    url?: undefined;
+                    method?: undefined;
+                    headers?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            })[];
+            export { anyOf_3 as anyOf };
+        }
+        namespace DataSet {
+            let type_86: string;
+            export { type_86 as type };
+            export namespace properties_14 {
+                export namespace name_6 {
+                    let type_87: string;
+                    export { type_87 as type };
+                }
+                export { name_6 as name };
+                export namespace source {
+                    let type_88: string;
+                    export { type_88 as type };
+                }
+                export namespace path_1 {
+                    let type_89: string;
+                    export { type_89 as type };
+                }
+                export { path_1 as path };
+                export namespace detectDates {
+                    let type_90: string;
+                    export { type_90 as type };
+                    let description_15: string;
+                    export { description_15 as description };
+                }
+                export namespace fields {
+                    let type_91: string;
+                    export { type_91 as type };
+                    export namespace items_6 {
+                        let $ref_10: string;
+                        export { $ref_10 as $ref };
+                    }
+                    export { items_6 as items };
+                    let description_16: string;
+                    export { description_16 as description };
+                }
+                export namespace filters {
+                    let type_92: string;
+                    export { type_92 as type };
+                    let items_7: {};
+                    export { items_7 as items };
+                }
+                export namespace sort_2 {
+                    let type_93: string;
+                    export { type_93 as type };
+                    export namespace items_8 {
+                        let $ref_11: string;
+                        export { $ref_11 as $ref };
+                    }
+                    export { items_8 as items };
+                    let description_17: string;
+                    export { description_17 as description };
+                }
+                export { sort_2 as sort };
+            }
+            export { properties_14 as properties };
+            let required_11: string[];
+            export { required_11 as required };
+            let additionalProperties_7: boolean;
+            export { additionalProperties_7 as additionalProperties };
+        }
+        namespace Report {
+            let description_18: string;
+            export { description_18 as description };
+            let type_94: string;
+            export { type_94 as type };
+            export namespace properties_15 {
+                export namespace $schema_1 {
+                    let description_19: string;
+                    export { description_19 as description };
+                    let _enum_11: string[];
+                    export { _enum_11 as enum };
+                }
+                export { $schema_1 as $schema };
+                export namespace name_7 {
+                    let type_95: string;
+                    export { type_95 as type };
+                }
+                export { name_7 as name };
+                export namespace description_20 {
+                    let type_96: string;
+                    export { type_96 as type };
+                }
+                export { description_20 as description };
+                export namespace locale {
+                    let type_97: string;
+                    export { type_97 as type };
+                }
+                export namespace currency {
+                    let type_98: string;
+                    export { type_98 as type };
+                    let description_21: string;
+                    export { description_21 as description };
+                }
+                export namespace nonFinite {
+                    let _enum_12: string[];
+                    export { _enum_12 as enum };
+                    let description_22: string;
+                    export { description_22 as description };
+                }
+                export namespace grouping {
+                    let _enum_13: string[];
+                    export { _enum_13 as enum };
+                    let description_23: string;
+                    export { description_23 as description };
+                }
+                export namespace page {
+                    let type_99: string;
+                    export { type_99 as type };
+                    export namespace properties_16 {
+                        let size_1: {
+                            "x-ts": string;
+                        };
+                        export { size_1 as size };
+                        export namespace orientation {
+                            let _enum_14: string[];
+                            export { _enum_14 as enum };
+                        }
+                        export let margins: {
+                            "x-ts": string;
+                            description: string;
+                        };
+                        export namespace width_2 {
+                            let type_100: string;
+                            export { type_100 as type };
+                        }
+                        export { width_2 as width };
+                        export namespace height_2 {
+                            let type_101: string;
+                            export { type_101 as type };
+                        }
+                        export { height_2 as height };
+                    }
+                    export { properties_16 as properties };
+                    let additionalProperties_8: boolean;
+                    export { additionalProperties_8 as additionalProperties };
+                }
+                export namespace parameters {
+                    let type_102: string;
+                    export { type_102 as type };
+                    export namespace items_9 {
+                        let $ref_12: string;
+                        export { $ref_12 as $ref };
+                    }
+                    export { items_9 as items };
+                }
+                export let parameterLayout: {};
+                export namespace liveParameters {
+                    let type_103: string;
+                    export { type_103 as type };
+                }
+                export namespace dataSources {
+                    let type_104: string;
+                    export { type_104 as type };
+                    export namespace items_10 {
+                        let $ref_13: string;
+                        export { $ref_13 as $ref };
+                    }
+                    export { items_10 as items };
+                }
+                export namespace dataSets {
+                    let type_105: string;
+                    export { type_105 as type };
+                    export namespace items_11 {
+                        let $ref_14: string;
+                        export { $ref_14 as $ref };
+                    }
+                    export { items_11 as items };
+                }
+                export namespace styles {
+                    let type_106: string;
+                    export { type_106 as type };
+                    export namespace properties_17 {
+                        namespace base {
+                            let $ref_15: string;
+                            export { $ref_15 as $ref };
+                        }
+                        let named: {
+                            "x-ts": string;
+                            type: string;
+                        };
+                    }
+                    export { properties_17 as properties };
+                }
+                export let images: {
+                    "x-ts": string;
+                    type: string;
+                    description: string;
+                };
+                export namespace sections {
+                    let type_107: string;
+                    export { type_107 as type };
+                    export namespace properties_18 {
+                        namespace pageHeader {
+                            let $ref_16: string;
+                            export { $ref_16 as $ref };
+                        }
+                        let body: {
+                            "x-ts": string;
+                        };
+                        namespace pageFooter {
+                            let $ref_17: string;
+                            export { $ref_17 as $ref };
+                        }
+                    }
+                    export { properties_18 as properties };
+                    let required_12: string[];
+                    export { required_12 as required };
+                }
+            }
+            export { properties_15 as properties };
+            let required_13: string[];
+            export { required_13 as required };
+            export let examples: {
+                $schema: string;
+                name: string;
+                page: {
+                    size: string;
+                    margins: number[];
+                };
+                dataSources: {
+                    name: string;
+                    type: string;
+                    data: {
+                        rows: {
+                            customer: string;
+                            amount: number;
+                        }[];
+                    };
+                }[];
+                dataSets: {
+                    name: string;
+                    source: string;
+                    path: string;
+                }[];
+                sections: {
+                    body: {
+                        items: ({
+                            type: string;
+                            name: string;
+                            x: number;
+                            y: number;
+                            w: number;
+                            h: number;
+                            value: string;
+                            style: {
+                                fontSize: number;
+                                fontWeight: string;
+                            };
+                            dataSet?: undefined;
+                            columns?: undefined;
+                            header?: undefined;
+                            detail?: undefined;
+                            footer?: undefined;
+                        } | {
+                            type: string;
+                            name: string;
+                            x: number;
+                            y: number;
+                            w: number;
+                            h: number;
+                            dataSet: string;
+                            columns: {
+                                width: number;
+                            }[];
+                            header: {
+                                height: number;
+                                cells: ({
+                                    value: string;
+                                    colSpan: number;
+                                } | {
+                                    value: string;
+                                    colSpan?: undefined;
+                                })[];
+                            }[];
+                            detail: {
+                                height: number;
+                                cells: ({
+                                    value: string;
+                                    style?: undefined;
+                                } | {
+                                    value: string;
+                                    style: {
+                                        format: string;
+                                    };
+                                })[];
+                            }[];
+                            footer: {
+                                height: number;
+                                cells: {
+                                    value: string;
+                                    colSpan: number;
+                                }[];
+                            }[];
+                            value?: undefined;
+                            style?: undefined;
+                        })[];
+                    };
+                };
+            }[];
+        }
+    }
+}