table 6.5.0 → 6.7.1

package/dist/generated/validators.js

@@ -8,6 +8,31 @@ const schema13 = {
         "border": {
             "$ref": "shared.json#/definitions/borders"
         },
+        "header": {
+            "type": "object",
+            "properties": {
+                "content": {
+                    "type": "string"
+                },
+                "alignment": {
+                    "$ref": "shared.json#/definitions/alignment"
+                },
+                "wrapWord": {
+                    "type": "boolean"
+                },
+                "truncate": {
+                    "type": "integer"
+                },
+                "paddingLeft": {
+                    "type": "integer"
+                },
+                "paddingRight": {
+                    "type": "integer"
+                }
+            },
+            "required": ["content"],
+            "additionalProperties": false
+        },
         "columns": {
             "$ref": "shared.json#/definitions/columns"
         },
@@ -62,6 +87,9 @@ const schema15 = {
         "bodyJoin": {
             "$ref": "#/definitions/border"
         },
+        "headerJoin": {
+            "$ref": "#/definitions/border"
+        },
         "joinBody": {
             "$ref": "#/definitions/border"
         },
@@ -250,6 +278,17 @@ function validate45(data, { instancePath = "", parentData, parentDataProperty, r
                 errors = vErrors.length;
             }
         }
+        if (data.headerJoin !== undefined) {
+            if (!(validate46(data.headerJoin, {
+                instancePath: instancePath + "/headerJoin",
+                parentData: data,
+                parentDataProperty: "headerJoin",
+                rootData
+            }))) {
+                vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
+                errors = vErrors.length;
+            }
+        }
         if (data.joinBody !== undefined) {
             if (!(validate46(data.joinBody, {
                 instancePath: instancePath + "/joinBody",
@@ -317,6 +356,53 @@ function validate45(data, { instancePath = "", parentData, parentDataProperty, r
     return errors === 0;
 }
 const schema17 = {
+    "type": "string",
+    "enum": ["left", "right", "center", "justify"]
+};
+const func0 = require("ajv/dist/runtime/equal").default;
+function validate64(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+    let vErrors = null;
+    let errors = 0;
+    if (typeof data !== "string") {
+        const err0 = {
+            instancePath,
+            schemaPath: "#/type",
+            keyword: "type",
+            params: {
+                type: "string"
+            },
+            message: "must be string"
+        };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!((((data === "left") || (data === "right")) || (data === "center")) || (data === "justify"))) {
+        const err1 = {
+            instancePath,
+            schemaPath: "#/enum",
+            keyword: "enum",
+            params: {
+                allowedValues: schema17.enum
+            },
+            message: "must be equal to one of the allowed values"
+        };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    validate64.errors = vErrors;
+    return errors === 0;
+}
+const schema18 = {
     "oneOf": [{
             "type": "object",
             "patternProperties": {
@@ -333,40 +419,83 @@ const schema17 = {
         }]
 };
 const pattern0 = new RegExp("^[0-9]+$", "u");
-const schema18 = {
+const schema19 = {
     "type": "object",
     "properties": {
         "alignment": {
+            "$ref": "#/definitions/alignment"
+        },
+        "verticalAlignment": {
             "type": "string",
-            "enum": ["left", "right", "center"]
+            "enum": ["top", "middle", "bottom"]
         },
         "width": {
-            "type": "number",
-            "minimum": 1,
-            "multipleOf": 1
+            "type": "integer",
+            "minimum": 1
         },
         "wrapWord": {
             "type": "boolean"
         },
         "truncate": {
-            "type": "number"
+            "type": "integer"
         },
         "paddingLeft": {
-            "type": "number"
+            "type": "integer"
         },
         "paddingRight": {
-            "type": "number"
+            "type": "integer"
         }
     },
     "additionalProperties": false
 };
-const func0 = require("ajv/dist/runtime/equal").default;
-function validate64(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+    let vErrors = null;
+    let errors = 0;
+    if (typeof data !== "string") {
+        const err0 = {
+            instancePath,
+            schemaPath: "#/type",
+            keyword: "type",
+            params: {
+                type: "string"
+            },
+            message: "must be string"
+        };
+        if (vErrors === null) {
+            vErrors = [err0];
+        }
+        else {
+            vErrors.push(err0);
+        }
+        errors++;
+    }
+    if (!((((data === "left") || (data === "right")) || (data === "center")) || (data === "justify"))) {
+        const err1 = {
+            instancePath,
+            schemaPath: "#/enum",
+            keyword: "enum",
+            params: {
+                allowedValues: schema17.enum
+            },
+            message: "must be equal to one of the allowed values"
+        };
+        if (vErrors === null) {
+            vErrors = [err1];
+        }
+        else {
+            vErrors.push(err1);
+        }
+        errors++;
+    }
+    validate68.errors = vErrors;
+    return errors === 0;
+}
+function validate67(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
+            if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -386,11 +515,22 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.alignment !== undefined) {
-            let data0 = data.alignment;
-            if (typeof data0 !== "string") {
+            if (!(validate68(data.alignment, {
+                instancePath: instancePath + "/alignment",
+                parentData: data,
+                parentDataProperty: "alignment",
+                rootData
+            }))) {
+                vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.verticalAlignment !== undefined) {
+            let data1 = data.verticalAlignment;
+            if (typeof data1 !== "string") {
                 const err1 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/type",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/type",
                     keyword: "type",
                     params: {
                         type: "string"
@@ -405,13 +545,13 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
                 }
                 errors++;
             }
-            if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
+            if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
                 const err2 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/enum",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/enum",
                     keyword: "enum",
                     params: {
-                        allowedValues: schema18.properties.alignment.enum
+                        allowedValues: schema19.properties.verticalAlignment.enum
                     },
                     message: "must be equal to one of the allowed values"
                 };
@@ -425,10 +565,28 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.width !== undefined) {
-            let data1 = data.width;
-            if ((typeof data1 == "number") && (isFinite(data1))) {
-                if (data1 < 1 || isNaN(data1)) {
-                    const err3 = {
+            let data2 = data.width;
+            if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
+                const err3 = {
+                    instancePath: instancePath + "/width",
+                    schemaPath: "#/properties/width/type",
+                    keyword: "type",
+                    params: {
+                        type: "integer"
+                    },
+                    message: "must be integer"
+                };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            if ((typeof data2 == "number") && (isFinite(data2))) {
+                if (data2 < 1 || isNaN(data2)) {
+                    const err4 = {
                         instancePath: instancePath + "/width",
                         schemaPath: "#/properties/width/minimum",
                         keyword: "minimum",
@@ -438,25 +596,6 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
                         },
                         message: "must be >= 1"
                     };
-                    if (vErrors === null) {
-                        vErrors = [err3];
-                    }
-                    else {
-                        vErrors.push(err3);
-                    }
-                    errors++;
-                }
-                let res0;
-                if ((1 === 0 || (res0 = data1 / 1, res0 !== parseInt(res0)))) {
-                    const err4 = {
-                        instancePath: instancePath + "/width",
-                        schemaPath: "#/properties/width/multipleOf",
-                        keyword: "multipleOf",
-                        params: {
-                            multipleOf: 1
-                        },
-                        message: "must be multiple of 1"
-                    };
                     if (vErrors === null) {
                         vErrors = [err4];
                     }
@@ -466,28 +605,10 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
                     errors++;
                 }
             }
-            else {
-                const err5 = {
-                    instancePath: instancePath + "/width",
-                    schemaPath: "#/properties/width/type",
-                    keyword: "type",
-                    params: {
-                        type: "number"
-                    },
-                    message: "must be number"
-                };
-                if (vErrors === null) {
-                    vErrors = [err5];
-                }
-                else {
-                    vErrors.push(err5);
-                }
-                errors++;
-            }
         }
         if (data.wrapWord !== undefined) {
             if (typeof data.wrapWord !== "boolean") {
-                const err6 = {
+                const err5 = {
                     instancePath: instancePath + "/wrapWord",
                     schemaPath: "#/properties/wrapWord/type",
                     keyword: "type",
@@ -497,80 +618,80 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "must be boolean"
                 };
                 if (vErrors === null) {
-                    vErrors = [err6];
+                    vErrors = [err5];
                 }
                 else {
-                    vErrors.push(err6);
+                    vErrors.push(err5);
                 }
                 errors++;
             }
         }
         if (data.truncate !== undefined) {
-            let data3 = data.truncate;
-            if (!((typeof data3 == "number") && (isFinite(data3)))) {
-                const err7 = {
+            let data4 = data.truncate;
+            if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
+                const err6 = {
                     instancePath: instancePath + "/truncate",
                     schemaPath: "#/properties/truncate/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err7];
+                    vErrors = [err6];
                 }
                 else {
-                    vErrors.push(err7);
+                    vErrors.push(err6);
                 }
                 errors++;
             }
         }
         if (data.paddingLeft !== undefined) {
-            let data4 = data.paddingLeft;
-            if (!((typeof data4 == "number") && (isFinite(data4)))) {
-                const err8 = {
+            let data5 = data.paddingLeft;
+            if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
+                const err7 = {
                     instancePath: instancePath + "/paddingLeft",
                     schemaPath: "#/properties/paddingLeft/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err8];
+                    vErrors = [err7];
                 }
                 else {
-                    vErrors.push(err8);
+                    vErrors.push(err7);
                 }
                 errors++;
             }
         }
         if (data.paddingRight !== undefined) {
-            let data5 = data.paddingRight;
-            if (!((typeof data5 == "number") && (isFinite(data5)))) {
-                const err9 = {
+            let data6 = data.paddingRight;
+            if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
+                const err8 = {
                     instancePath: instancePath + "/paddingRight",
                     schemaPath: "#/properties/paddingRight/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err9];
+                    vErrors = [err8];
                 }
                 else {
-                    vErrors.push(err9);
+                    vErrors.push(err8);
                 }
                 errors++;
             }
         }
     }
     else {
-        const err10 = {
+        const err9 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -580,17 +701,17 @@ function validate64(data, { instancePath = "", parentData, parentDataProperty, r
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err10];
+            vErrors = [err9];
         }
         else {
-            vErrors.push(err10);
+            vErrors.push(err9);
         }
         errors++;
     }
-    validate64.errors = vErrors;
+    validate67.errors = vErrors;
     return errors === 0;
 }
-function validate63(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate66(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     const _errs0 = errors;
@@ -620,13 +741,13 @@ function validate63(data, { instancePath = "", parentData, parentDataProperty, r
         }
         for (const key1 in data) {
             if (pattern0.test(key1)) {
-                if (!(validate64(data[key1], {
+                if (!(validate67(data[key1], {
                     instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
                     parentData: data,
                     parentDataProperty: key1,
                     rootData
                 }))) {
-                    vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
+                    vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
                     errors = vErrors.length;
                 }
             }
@@ -659,13 +780,13 @@ function validate63(data, { instancePath = "", parentData, parentDataProperty, r
     if (Array.isArray(data)) {
         const len0 = data.length;
         for (let i0 = 0; i0 < len0; i0++) {
-            if (!(validate64(data[i0], {
+            if (!(validate67(data[i0], {
                 instancePath: instancePath + "/" + i0,
                 parentData: data,
                 parentDataProperty: i0,
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
+                vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
                 errors = vErrors.length;
             }
         }
@@ -728,15 +849,15 @@ function validate63(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
     }
-    validate63.errors = vErrors;
+    validate66.errors = vErrors;
     return errors === 0;
 }
-function validate68(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate73(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
+            if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -756,11 +877,22 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.alignment !== undefined) {
-            let data0 = data.alignment;
-            if (typeof data0 !== "string") {
+            if (!(validate68(data.alignment, {
+                instancePath: instancePath + "/alignment",
+                parentData: data,
+                parentDataProperty: "alignment",
+                rootData
+            }))) {
+                vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.verticalAlignment !== undefined) {
+            let data1 = data.verticalAlignment;
+            if (typeof data1 !== "string") {
                 const err1 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/type",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/type",
                     keyword: "type",
                     params: {
                         type: "string"
@@ -775,13 +907,13 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
                 }
                 errors++;
             }
-            if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
+            if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
                 const err2 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/enum",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/enum",
                     keyword: "enum",
                     params: {
-                        allowedValues: schema18.properties.alignment.enum
+                        allowedValues: schema19.properties.verticalAlignment.enum
                     },
                     message: "must be equal to one of the allowed values"
                 };
@@ -795,10 +927,28 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.width !== undefined) {
-            let data1 = data.width;
-            if ((typeof data1 == "number") && (isFinite(data1))) {
-                if (data1 < 1 || isNaN(data1)) {
-                    const err3 = {
+            let data2 = data.width;
+            if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
+                const err3 = {
+                    instancePath: instancePath + "/width",
+                    schemaPath: "#/properties/width/type",
+                    keyword: "type",
+                    params: {
+                        type: "integer"
+                    },
+                    message: "must be integer"
+                };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            if ((typeof data2 == "number") && (isFinite(data2))) {
+                if (data2 < 1 || isNaN(data2)) {
+                    const err4 = {
                         instancePath: instancePath + "/width",
                         schemaPath: "#/properties/width/minimum",
                         keyword: "minimum",
@@ -808,25 +958,6 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
                         },
                         message: "must be >= 1"
                     };
-                    if (vErrors === null) {
-                        vErrors = [err3];
-                    }
-                    else {
-                        vErrors.push(err3);
-                    }
-                    errors++;
-                }
-                let res0;
-                if ((1 === 0 || (res0 = data1 / 1, res0 !== parseInt(res0)))) {
-                    const err4 = {
-                        instancePath: instancePath + "/width",
-                        schemaPath: "#/properties/width/multipleOf",
-                        keyword: "multipleOf",
-                        params: {
-                            multipleOf: 1
-                        },
-                        message: "must be multiple of 1"
-                    };
                     if (vErrors === null) {
                         vErrors = [err4];
                     }
@@ -836,28 +967,10 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
                     errors++;
                 }
             }
-            else {
-                const err5 = {
-                    instancePath: instancePath + "/width",
-                    schemaPath: "#/properties/width/type",
-                    keyword: "type",
-                    params: {
-                        type: "number"
-                    },
-                    message: "must be number"
-                };
-                if (vErrors === null) {
-                    vErrors = [err5];
-                }
-                else {
-                    vErrors.push(err5);
-                }
-                errors++;
-            }
         }
         if (data.wrapWord !== undefined) {
             if (typeof data.wrapWord !== "boolean") {
-                const err6 = {
+                const err5 = {
                     instancePath: instancePath + "/wrapWord",
                     schemaPath: "#/properties/wrapWord/type",
                     keyword: "type",
@@ -867,80 +980,80 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "must be boolean"
                 };
                 if (vErrors === null) {
-                    vErrors = [err6];
+                    vErrors = [err5];
                 }
                 else {
-                    vErrors.push(err6);
+                    vErrors.push(err5);
                 }
                 errors++;
             }
         }
         if (data.truncate !== undefined) {
-            let data3 = data.truncate;
-            if (!((typeof data3 == "number") && (isFinite(data3)))) {
-                const err7 = {
+            let data4 = data.truncate;
+            if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
+                const err6 = {
                     instancePath: instancePath + "/truncate",
                     schemaPath: "#/properties/truncate/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err7];
+                    vErrors = [err6];
                 }
                 else {
-                    vErrors.push(err7);
+                    vErrors.push(err6);
                 }
                 errors++;
             }
         }
         if (data.paddingLeft !== undefined) {
-            let data4 = data.paddingLeft;
-            if (!((typeof data4 == "number") && (isFinite(data4)))) {
-                const err8 = {
+            let data5 = data.paddingLeft;
+            if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
+                const err7 = {
                     instancePath: instancePath + "/paddingLeft",
                     schemaPath: "#/properties/paddingLeft/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err8];
+                    vErrors = [err7];
                 }
                 else {
-                    vErrors.push(err8);
+                    vErrors.push(err7);
                 }
                 errors++;
             }
         }
         if (data.paddingRight !== undefined) {
-            let data5 = data.paddingRight;
-            if (!((typeof data5 == "number") && (isFinite(data5)))) {
-                const err9 = {
+            let data6 = data.paddingRight;
+            if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
+                const err8 = {
                     instancePath: instancePath + "/paddingRight",
                     schemaPath: "#/properties/paddingRight/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err9];
+                    vErrors = [err8];
                 }
                 else {
-                    vErrors.push(err9);
+                    vErrors.push(err8);
                 }
                 errors++;
             }
         }
     }
     else {
-        const err10 = {
+        const err9 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -950,14 +1063,14 @@ function validate68(data, { instancePath = "", parentData, parentDataProperty, r
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err10];
+            vErrors = [err9];
         }
         else {
-            vErrors.push(err10);
+            vErrors.push(err9);
         }
         errors++;
     }
-    validate68.errors = vErrors;
+    validate73.errors = vErrors;
     return errors === 0;
 }
 function validate43(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
@@ -966,7 +1079,7 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!((((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawVerticalLine")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
+            if (!(((((((key0 === "border") || (key0 === "header")) || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawVerticalLine")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -996,31 +1109,206 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
                 errors = vErrors.length;
             }
         }
+        if (data.header !== undefined) {
+            let data1 = data.header;
+            if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
+                if (data1.content === undefined) {
+                    const err1 = {
+                        instancePath: instancePath + "/header",
+                        schemaPath: "#/properties/header/required",
+                        keyword: "required",
+                        params: {
+                            missingProperty: "content"
+                        },
+                        message: "must have required property '" + "content" + "'"
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err1];
+                    }
+                    else {
+                        vErrors.push(err1);
+                    }
+                    errors++;
+                }
+                for (const key1 in data1) {
+                    if (!((((((key1 === "content") || (key1 === "alignment")) || (key1 === "wrapWord")) || (key1 === "truncate")) || (key1 === "paddingLeft")) || (key1 === "paddingRight"))) {
+                        const err2 = {
+                            instancePath: instancePath + "/header",
+                            schemaPath: "#/properties/header/additionalProperties",
+                            keyword: "additionalProperties",
+                            params: {
+                                additionalProperty: key1
+                            },
+                            message: "must NOT have additional properties"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err2];
+                        }
+                        else {
+                            vErrors.push(err2);
+                        }
+                        errors++;
+                    }
+                }
+                if (data1.content !== undefined) {
+                    if (typeof data1.content !== "string") {
+                        const err3 = {
+                            instancePath: instancePath + "/header/content",
+                            schemaPath: "#/properties/header/properties/content/type",
+                            keyword: "type",
+                            params: {
+                                type: "string"
+                            },
+                            message: "must be string"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err3];
+                        }
+                        else {
+                            vErrors.push(err3);
+                        }
+                        errors++;
+                    }
+                }
+                if (data1.alignment !== undefined) {
+                    if (!(validate64(data1.alignment, {
+                        instancePath: instancePath + "/header/alignment",
+                        parentData: data1,
+                        parentDataProperty: "alignment",
+                        rootData
+                    }))) {
+                        vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
+                        errors = vErrors.length;
+                    }
+                }
+                if (data1.wrapWord !== undefined) {
+                    if (typeof data1.wrapWord !== "boolean") {
+                        const err4 = {
+                            instancePath: instancePath + "/header/wrapWord",
+                            schemaPath: "#/properties/header/properties/wrapWord/type",
+                            keyword: "type",
+                            params: {
+                                type: "boolean"
+                            },
+                            message: "must be boolean"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err4];
+                        }
+                        else {
+                            vErrors.push(err4);
+                        }
+                        errors++;
+                    }
+                }
+                if (data1.truncate !== undefined) {
+                    let data5 = data1.truncate;
+                    if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
+                        const err5 = {
+                            instancePath: instancePath + "/header/truncate",
+                            schemaPath: "#/properties/header/properties/truncate/type",
+                            keyword: "type",
+                            params: {
+                                type: "integer"
+                            },
+                            message: "must be integer"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err5];
+                        }
+                        else {
+                            vErrors.push(err5);
+                        }
+                        errors++;
+                    }
+                }
+                if (data1.paddingLeft !== undefined) {
+                    let data6 = data1.paddingLeft;
+                    if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
+                        const err6 = {
+                            instancePath: instancePath + "/header/paddingLeft",
+                            schemaPath: "#/properties/header/properties/paddingLeft/type",
+                            keyword: "type",
+                            params: {
+                                type: "integer"
+                            },
+                            message: "must be integer"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err6];
+                        }
+                        else {
+                            vErrors.push(err6);
+                        }
+                        errors++;
+                    }
+                }
+                if (data1.paddingRight !== undefined) {
+                    let data7 = data1.paddingRight;
+                    if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
+                        const err7 = {
+                            instancePath: instancePath + "/header/paddingRight",
+                            schemaPath: "#/properties/header/properties/paddingRight/type",
+                            keyword: "type",
+                            params: {
+                                type: "integer"
+                            },
+                            message: "must be integer"
+                        };
+                        if (vErrors === null) {
+                            vErrors = [err7];
+                        }
+                        else {
+                            vErrors.push(err7);
+                        }
+                        errors++;
+                    }
+                }
+            }
+            else {
+                const err8 = {
+                    instancePath: instancePath + "/header",
+                    schemaPath: "#/properties/header/type",
+                    keyword: "type",
+                    params: {
+                        type: "object"
+                    },
+                    message: "must be object"
+                };
+                if (vErrors === null) {
+                    vErrors = [err8];
+                }
+                else {
+                    vErrors.push(err8);
+                }
+                errors++;
+            }
+        }
         if (data.columns !== undefined) {
-            if (!(validate63(data.columns, {
+            if (!(validate66(data.columns, {
                 instancePath: instancePath + "/columns",
                 parentData: data,
                 parentDataProperty: "columns",
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate63.errors : vErrors.concat(validate63.errors);
+                vErrors = vErrors === null ? validate66.errors : vErrors.concat(validate66.errors);
                 errors = vErrors.length;
             }
         }
         if (data.columnDefault !== undefined) {
-            if (!(validate68(data.columnDefault, {
+            if (!(validate73(data.columnDefault, {
                 instancePath: instancePath + "/columnDefault",
                 parentData: data,
                 parentDataProperty: "columnDefault",
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
+                vErrors = vErrors === null ? validate73.errors : vErrors.concat(validate73.errors);
                 errors = vErrors.length;
             }
         }
         if (data.drawVerticalLine !== undefined) {
             if (typeof data.drawVerticalLine != "function") {
-                const err1 = {
+                const err9 = {
                     instancePath: instancePath + "/drawVerticalLine",
                     schemaPath: "#/properties/drawVerticalLine/typeof",
                     keyword: "typeof",
@@ -1028,17 +1316,17 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err1];
+                    vErrors = [err9];
                 }
                 else {
-                    vErrors.push(err1);
+                    vErrors.push(err9);
                 }
                 errors++;
             }
         }
         if (data.drawHorizontalLine !== undefined) {
             if (typeof data.drawHorizontalLine != "function") {
-                const err2 = {
+                const err10 = {
                     instancePath: instancePath + "/drawHorizontalLine",
                     schemaPath: "#/properties/drawHorizontalLine/typeof",
                     keyword: "typeof",
@@ -1046,17 +1334,17 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err2];
+                    vErrors = [err10];
                 }
                 else {
-                    vErrors.push(err2);
+                    vErrors.push(err10);
                 }
                 errors++;
             }
         }
         if (data.singleLine !== undefined) {
             if (typeof data.singleLine != "boolean") {
-                const err3 = {
+                const err11 = {
                     instancePath: instancePath + "/singleLine",
                     schemaPath: "#/properties/singleLine/typeof",
                     keyword: "typeof",
@@ -1064,17 +1352,17 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err3];
+                    vErrors = [err11];
                 }
                 else {
-                    vErrors.push(err3);
+                    vErrors.push(err11);
                 }
                 errors++;
             }
         }
     }
     else {
-        const err4 = {
+        const err12 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -1084,18 +1372,18 @@ function validate43(data, { instancePath = "", parentData, parentDataProperty, r
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err4];
+            vErrors = [err12];
         }
         else {
-            vErrors.push(err4);
+            vErrors.push(err12);
         }
         errors++;
     }
     validate43.errors = vErrors;
     return errors === 0;
 }
-exports["streamConfig.json"] = validate70;
-const schema20 = {
+exports["streamConfig.json"] = validate76;
+const schema22 = {
     "$id": "streamConfig.json",
     "$schema": "http://json-schema.org/draft-07/schema#",
     "type": "object",
@@ -1110,15 +1398,17 @@ const schema20 = {
             "$ref": "shared.json#/definitions/column"
         },
         "columnCount": {
-            "type": "number"
+            "type": "integer",
+            "minimum": 1
         },
         "drawVerticalLine": {
             "typeof": "function"
         }
     },
+    "required": ["columnDefault", "columnCount"],
     "additionalProperties": false
 };
-function validate71(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate77(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
@@ -1263,6 +1553,17 @@ function validate71(data, { instancePath = "", parentData, parentDataProperty, r
                 errors = vErrors.length;
             }
         }
+        if (data.headerJoin !== undefined) {
+            if (!(validate46(data.headerJoin, {
+                instancePath: instancePath + "/headerJoin",
+                parentData: data,
+                parentDataProperty: "headerJoin",
+                rootData
+            }))) {
+                vErrors = vErrors === null ? validate46.errors : vErrors.concat(validate46.errors);
+                errors = vErrors.length;
+            }
+        }
         if (data.joinBody !== undefined) {
             if (!(validate46(data.joinBody, {
                 instancePath: instancePath + "/joinBody",
@@ -1326,10 +1627,10 @@ function validate71(data, { instancePath = "", parentData, parentDataProperty, r
         }
         errors++;
     }
-    validate71.errors = vErrors;
+    validate77.errors = vErrors;
     return errors === 0;
 }
-function validate88(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate95(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     const _errs0 = errors;
@@ -1359,13 +1660,13 @@ function validate88(data, { instancePath = "", parentData, parentDataProperty, r
         }
         for (const key1 in data) {
             if (pattern0.test(key1)) {
-                if (!(validate64(data[key1], {
+                if (!(validate67(data[key1], {
                     instancePath: instancePath + "/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),
                     parentData: data,
                     parentDataProperty: key1,
                     rootData
                 }))) {
-                    vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
+                    vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
                     errors = vErrors.length;
                 }
             }
@@ -1398,13 +1699,13 @@ function validate88(data, { instancePath = "", parentData, parentDataProperty, r
     if (Array.isArray(data)) {
         const len0 = data.length;
         for (let i0 = 0; i0 < len0; i0++) {
-            if (!(validate64(data[i0], {
+            if (!(validate67(data[i0], {
                 instancePath: instancePath + "/" + i0,
                 parentData: data,
                 parentDataProperty: i0,
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate64.errors : vErrors.concat(validate64.errors);
+                vErrors = vErrors === null ? validate67.errors : vErrors.concat(validate67.errors);
                 errors = vErrors.length;
             }
         }
@@ -1467,15 +1768,15 @@ function validate88(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
     }
-    validate88.errors = vErrors;
+    validate95.errors = vErrors;
     return errors === 0;
 }
-function validate92(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate99(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     let vErrors = null;
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!((((((key0 === "alignment") || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
+            if (!(((((((key0 === "alignment") || (key0 === "verticalAlignment")) || (key0 === "width")) || (key0 === "wrapWord")) || (key0 === "truncate")) || (key0 === "paddingLeft")) || (key0 === "paddingRight"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -1495,11 +1796,22 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.alignment !== undefined) {
-            let data0 = data.alignment;
-            if (typeof data0 !== "string") {
+            if (!(validate68(data.alignment, {
+                instancePath: instancePath + "/alignment",
+                parentData: data,
+                parentDataProperty: "alignment",
+                rootData
+            }))) {
+                vErrors = vErrors === null ? validate68.errors : vErrors.concat(validate68.errors);
+                errors = vErrors.length;
+            }
+        }
+        if (data.verticalAlignment !== undefined) {
+            let data1 = data.verticalAlignment;
+            if (typeof data1 !== "string") {
                 const err1 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/type",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/type",
                     keyword: "type",
                     params: {
                         type: "string"
@@ -1514,13 +1826,13 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
                 }
                 errors++;
             }
-            if (!(((data0 === "left") || (data0 === "right")) || (data0 === "center"))) {
+            if (!(((data1 === "top") || (data1 === "middle")) || (data1 === "bottom"))) {
                 const err2 = {
-                    instancePath: instancePath + "/alignment",
-                    schemaPath: "#/properties/alignment/enum",
+                    instancePath: instancePath + "/verticalAlignment",
+                    schemaPath: "#/properties/verticalAlignment/enum",
                     keyword: "enum",
                     params: {
-                        allowedValues: schema18.properties.alignment.enum
+                        allowedValues: schema19.properties.verticalAlignment.enum
                     },
                     message: "must be equal to one of the allowed values"
                 };
@@ -1534,10 +1846,28 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
             }
         }
         if (data.width !== undefined) {
-            let data1 = data.width;
-            if ((typeof data1 == "number") && (isFinite(data1))) {
-                if (data1 < 1 || isNaN(data1)) {
-                    const err3 = {
+            let data2 = data.width;
+            if (!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))) {
+                const err3 = {
+                    instancePath: instancePath + "/width",
+                    schemaPath: "#/properties/width/type",
+                    keyword: "type",
+                    params: {
+                        type: "integer"
+                    },
+                    message: "must be integer"
+                };
+                if (vErrors === null) {
+                    vErrors = [err3];
+                }
+                else {
+                    vErrors.push(err3);
+                }
+                errors++;
+            }
+            if ((typeof data2 == "number") && (isFinite(data2))) {
+                if (data2 < 1 || isNaN(data2)) {
+                    const err4 = {
                         instancePath: instancePath + "/width",
                         schemaPath: "#/properties/width/minimum",
                         keyword: "minimum",
@@ -1547,25 +1877,6 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
                         },
                         message: "must be >= 1"
                     };
-                    if (vErrors === null) {
-                        vErrors = [err3];
-                    }
-                    else {
-                        vErrors.push(err3);
-                    }
-                    errors++;
-                }
-                let res0;
-                if ((1 === 0 || (res0 = data1 / 1, res0 !== parseInt(res0)))) {
-                    const err4 = {
-                        instancePath: instancePath + "/width",
-                        schemaPath: "#/properties/width/multipleOf",
-                        keyword: "multipleOf",
-                        params: {
-                            multipleOf: 1
-                        },
-                        message: "must be multiple of 1"
-                    };
                     if (vErrors === null) {
                         vErrors = [err4];
                     }
@@ -1575,28 +1886,10 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
                     errors++;
                 }
             }
-            else {
-                const err5 = {
-                    instancePath: instancePath + "/width",
-                    schemaPath: "#/properties/width/type",
-                    keyword: "type",
-                    params: {
-                        type: "number"
-                    },
-                    message: "must be number"
-                };
-                if (vErrors === null) {
-                    vErrors = [err5];
-                }
-                else {
-                    vErrors.push(err5);
-                }
-                errors++;
-            }
         }
         if (data.wrapWord !== undefined) {
             if (typeof data.wrapWord !== "boolean") {
-                const err6 = {
+                const err5 = {
                     instancePath: instancePath + "/wrapWord",
                     schemaPath: "#/properties/wrapWord/type",
                     keyword: "type",
@@ -1606,80 +1899,80 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "must be boolean"
                 };
                 if (vErrors === null) {
-                    vErrors = [err6];
+                    vErrors = [err5];
                 }
                 else {
-                    vErrors.push(err6);
+                    vErrors.push(err5);
                 }
                 errors++;
             }
         }
         if (data.truncate !== undefined) {
-            let data3 = data.truncate;
-            if (!((typeof data3 == "number") && (isFinite(data3)))) {
-                const err7 = {
+            let data4 = data.truncate;
+            if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
+                const err6 = {
                     instancePath: instancePath + "/truncate",
                     schemaPath: "#/properties/truncate/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err7];
+                    vErrors = [err6];
                 }
                 else {
-                    vErrors.push(err7);
+                    vErrors.push(err6);
                 }
                 errors++;
             }
         }
         if (data.paddingLeft !== undefined) {
-            let data4 = data.paddingLeft;
-            if (!((typeof data4 == "number") && (isFinite(data4)))) {
-                const err8 = {
+            let data5 = data.paddingLeft;
+            if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
+                const err7 = {
                     instancePath: instancePath + "/paddingLeft",
                     schemaPath: "#/properties/paddingLeft/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err8];
+                    vErrors = [err7];
                 }
                 else {
-                    vErrors.push(err8);
+                    vErrors.push(err7);
                 }
                 errors++;
             }
         }
         if (data.paddingRight !== undefined) {
-            let data5 = data.paddingRight;
-            if (!((typeof data5 == "number") && (isFinite(data5)))) {
-                const err9 = {
+            let data6 = data.paddingRight;
+            if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
+                const err8 = {
                     instancePath: instancePath + "/paddingRight",
                     schemaPath: "#/properties/paddingRight/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err9];
+                    vErrors = [err8];
                 }
                 else {
-                    vErrors.push(err9);
+                    vErrors.push(err8);
                 }
                 errors++;
             }
         }
     }
     else {
-        const err10 = {
+        const err9 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -1689,24 +1982,60 @@ function validate92(data, { instancePath = "", parentData, parentDataProperty, r
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err10];
+            vErrors = [err9];
         }
         else {
-            vErrors.push(err10);
+            vErrors.push(err9);
         }
         errors++;
     }
-    validate92.errors = vErrors;
+    validate99.errors = vErrors;
     return errors === 0;
 }
-function validate70(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate76(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
     /*# sourceURL="streamConfig.json" */ ;
     let vErrors = null;
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
+        if (data.columnDefault === undefined) {
+            const err0 = {
+                instancePath,
+                schemaPath: "#/required",
+                keyword: "required",
+                params: {
+                    missingProperty: "columnDefault"
+                },
+                message: "must have required property '" + "columnDefault" + "'"
+            };
+            if (vErrors === null) {
+                vErrors = [err0];
+            }
+            else {
+                vErrors.push(err0);
+            }
+            errors++;
+        }
+        if (data.columnCount === undefined) {
+            const err1 = {
+                instancePath,
+                schemaPath: "#/required",
+                keyword: "required",
+                params: {
+                    missingProperty: "columnCount"
+                },
+                message: "must have required property '" + "columnCount" + "'"
+            };
+            if (vErrors === null) {
+                vErrors = [err1];
+            }
+            else {
+                vErrors.push(err1);
+            }
+            errors++;
+        }
         for (const key0 in data) {
             if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount")) || (key0 === "drawVerticalLine"))) {
-                const err0 = {
+                const err2 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
                     keyword: "additionalProperties",
@@ -1716,71 +2045,92 @@ function validate70(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "must NOT have additional properties"
                 };
                 if (vErrors === null) {
-                    vErrors = [err0];
+                    vErrors = [err2];
                 }
                 else {
-                    vErrors.push(err0);
+                    vErrors.push(err2);
                 }
                 errors++;
             }
         }
         if (data.border !== undefined) {
-            if (!(validate71(data.border, {
+            if (!(validate77(data.border, {
                 instancePath: instancePath + "/border",
                 parentData: data,
                 parentDataProperty: "border",
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate71.errors : vErrors.concat(validate71.errors);
+                vErrors = vErrors === null ? validate77.errors : vErrors.concat(validate77.errors);
                 errors = vErrors.length;
             }
         }
         if (data.columns !== undefined) {
-            if (!(validate88(data.columns, {
+            if (!(validate95(data.columns, {
                 instancePath: instancePath + "/columns",
                 parentData: data,
                 parentDataProperty: "columns",
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate88.errors : vErrors.concat(validate88.errors);
+                vErrors = vErrors === null ? validate95.errors : vErrors.concat(validate95.errors);
                 errors = vErrors.length;
             }
         }
         if (data.columnDefault !== undefined) {
-            if (!(validate92(data.columnDefault, {
+            if (!(validate99(data.columnDefault, {
                 instancePath: instancePath + "/columnDefault",
                 parentData: data,
                 parentDataProperty: "columnDefault",
                 rootData
             }))) {
-                vErrors = vErrors === null ? validate92.errors : vErrors.concat(validate92.errors);
+                vErrors = vErrors === null ? validate99.errors : vErrors.concat(validate99.errors);
                 errors = vErrors.length;
             }
         }
         if (data.columnCount !== undefined) {
             let data3 = data.columnCount;
-            if (!((typeof data3 == "number") && (isFinite(data3)))) {
-                const err1 = {
+            if (!(((typeof data3 == "number") && (!(data3 % 1) && !isNaN(data3))) && (isFinite(data3)))) {
+                const err3 = {
                     instancePath: instancePath + "/columnCount",
                     schemaPath: "#/properties/columnCount/type",
                     keyword: "type",
                     params: {
-                        type: "number"
+                        type: "integer"
                     },
-                    message: "must be number"
+                    message: "must be integer"
                 };
                 if (vErrors === null) {
-                    vErrors = [err1];
+                    vErrors = [err3];
                 }
                 else {
-                    vErrors.push(err1);
+                    vErrors.push(err3);
                 }
                 errors++;
             }
+            if ((typeof data3 == "number") && (isFinite(data3))) {
+                if (data3 < 1 || isNaN(data3)) {
+                    const err4 = {
+                        instancePath: instancePath + "/columnCount",
+                        schemaPath: "#/properties/columnCount/minimum",
+                        keyword: "minimum",
+                        params: {
+                            comparison: ">=",
+                            limit: 1
+                        },
+                        message: "must be >= 1"
+                    };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                }
+            }
         }
         if (data.drawVerticalLine !== undefined) {
             if (typeof data.drawVerticalLine != "function") {
-                const err2 = {
+                const err5 = {
                     instancePath: instancePath + "/drawVerticalLine",
                     schemaPath: "#/properties/drawVerticalLine/typeof",
                     keyword: "typeof",
@@ -1788,17 +2138,17 @@ function validate70(data, { instancePath = "", parentData, parentDataProperty, r
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err2];
+                    vErrors = [err5];
                 }
                 else {
-                    vErrors.push(err2);
+                    vErrors.push(err5);
                 }
                 errors++;
             }
         }
     }
     else {
-        const err3 = {
+        const err6 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -1808,13 +2158,13 @@ function validate70(data, { instancePath = "", parentData, parentDataProperty, r
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err3];
+            vErrors = [err6];
         }
         else {
-            vErrors.push(err3);
+            vErrors.push(err6);
         }
         errors++;
     }
-    validate70.errors = vErrors;
+    validate76.errors = vErrors;
     return errors === 0;
 }