You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
752 lines
24 KiB
752 lines
24 KiB
'use strict'; |
|
var equal = require('ajv/lib/compile/equal'); |
|
var validate = (function() { |
|
var pattern0 = new RegExp('^[0-9]+$'); |
|
var refVal = []; |
|
var refVal1 = (function() { |
|
var pattern0 = new RegExp('^[0-9]+$'); |
|
return function validate(data, dataPath, parentData, parentDataProperty, rootData) { |
|
'use strict'; |
|
var vErrors = null; |
|
var errors = 0; |
|
if (rootData === undefined) rootData = data; |
|
if ((data && typeof data === "object" && !Array.isArray(data))) { |
|
var errs__0 = errors; |
|
var valid1 = true; |
|
for (var key0 in data) { |
|
var isAdditional0 = !(false || validate.schema.properties.hasOwnProperty(key0)); |
|
if (isAdditional0) { |
|
valid1 = false; |
|
var err = { |
|
keyword: 'additionalProperties', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/additionalProperties', |
|
params: { |
|
additionalProperty: '' + key0 + '' |
|
}, |
|
message: 'should NOT have additional properties' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
} |
|
if (data.topBody !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal2(data.topBody, (dataPath || '') + '.topBody', data, 'topBody', rootData)) { |
|
if (vErrors === null) vErrors = refVal2.errors; |
|
else vErrors = vErrors.concat(refVal2.errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.topJoin !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.topJoin, (dataPath || '') + '.topJoin', data, 'topJoin', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.topLeft !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.topLeft, (dataPath || '') + '.topLeft', data, 'topLeft', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.topRight !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.topRight, (dataPath || '') + '.topRight', data, 'topRight', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bottomBody !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bottomBody, (dataPath || '') + '.bottomBody', data, 'bottomBody', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bottomJoin !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bottomJoin, (dataPath || '') + '.bottomJoin', data, 'bottomJoin', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bottomLeft !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bottomLeft, (dataPath || '') + '.bottomLeft', data, 'bottomLeft', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bottomRight !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bottomRight, (dataPath || '') + '.bottomRight', data, 'bottomRight', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bodyLeft !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bodyLeft, (dataPath || '') + '.bodyLeft', data, 'bodyLeft', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bodyRight !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bodyRight, (dataPath || '') + '.bodyRight', data, 'bodyRight', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.bodyJoin !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.bodyJoin, (dataPath || '') + '.bodyJoin', data, 'bodyJoin', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.joinBody !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.joinBody, (dataPath || '') + '.joinBody', data, 'joinBody', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.joinLeft !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.joinLeft, (dataPath || '') + '.joinLeft', data, 'joinLeft', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.joinRight !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.joinRight, (dataPath || '') + '.joinRight', data, 'joinRight', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.joinJoin !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[2](data.joinJoin, (dataPath || '') + '.joinJoin', data, 'joinJoin', rootData)) { |
|
if (vErrors === null) vErrors = refVal[2].errors; |
|
else vErrors = vErrors.concat(refVal[2].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
} else { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/type', |
|
params: { |
|
type: 'object' |
|
}, |
|
message: 'should be object' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
validate.errors = vErrors; |
|
return errors === 0; |
|
}; |
|
})(); |
|
refVal1.schema = { |
|
"type": "object", |
|
"properties": { |
|
"topBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinJoin": { |
|
"$ref": "#/definitions/border" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}; |
|
refVal1.errors = null; |
|
refVal[1] = refVal1; |
|
var refVal2 = (function() { |
|
var pattern0 = new RegExp('^[0-9]+$'); |
|
return function validate(data, dataPath, parentData, parentDataProperty, rootData) { |
|
'use strict'; |
|
var vErrors = null; |
|
var errors = 0; |
|
if (typeof data !== "string") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/type', |
|
params: { |
|
type: 'string' |
|
}, |
|
message: 'should be string' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
validate.errors = vErrors; |
|
return errors === 0; |
|
}; |
|
})(); |
|
refVal2.schema = { |
|
"type": "string" |
|
}; |
|
refVal2.errors = null; |
|
refVal[2] = refVal2; |
|
var refVal3 = (function() { |
|
var pattern0 = new RegExp('^[0-9]+$'); |
|
return function validate(data, dataPath, parentData, parentDataProperty, rootData) { |
|
'use strict'; |
|
var vErrors = null; |
|
var errors = 0; |
|
if (rootData === undefined) rootData = data; |
|
if ((data && typeof data === "object" && !Array.isArray(data))) { |
|
var errs__0 = errors; |
|
var valid1 = true; |
|
for (var key0 in data) { |
|
var isAdditional0 = !(false || pattern0.test(key0)); |
|
if (isAdditional0) { |
|
valid1 = false; |
|
var err = { |
|
keyword: 'additionalProperties', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/additionalProperties', |
|
params: { |
|
additionalProperty: '' + key0 + '' |
|
}, |
|
message: 'should NOT have additional properties' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
} |
|
for (var key0 in data) { |
|
if (pattern0.test(key0)) { |
|
var errs_1 = errors; |
|
if (!refVal4(data[key0], (dataPath || '') + '[\'' + key0 + '\']', data, key0, rootData)) { |
|
if (vErrors === null) vErrors = refVal4.errors; |
|
else vErrors = vErrors.concat(refVal4.errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
} |
|
} else { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/type', |
|
params: { |
|
type: 'object' |
|
}, |
|
message: 'should be object' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
validate.errors = vErrors; |
|
return errors === 0; |
|
}; |
|
})(); |
|
refVal3.schema = { |
|
"type": "object", |
|
"patternProperties": { |
|
"^[0-9]+$": { |
|
"$ref": "#/definitions/column" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}; |
|
refVal3.errors = null; |
|
refVal[3] = refVal3; |
|
var refVal4 = (function() { |
|
var pattern0 = new RegExp('^[0-9]+$'); |
|
return function validate(data, dataPath, parentData, parentDataProperty, rootData) { |
|
'use strict'; |
|
var vErrors = null; |
|
var errors = 0; |
|
if ((data && typeof data === "object" && !Array.isArray(data))) { |
|
var errs__0 = errors; |
|
var valid1 = true; |
|
for (var key0 in data) { |
|
var isAdditional0 = !(false || key0 == 'alignment' || key0 == 'width' || key0 == 'wrapWord' || key0 == 'truncate' || key0 == 'paddingLeft' || key0 == 'paddingRight'); |
|
if (isAdditional0) { |
|
valid1 = false; |
|
var err = { |
|
keyword: 'additionalProperties', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/additionalProperties', |
|
params: { |
|
additionalProperty: '' + key0 + '' |
|
}, |
|
message: 'should NOT have additional properties' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
} |
|
var data1 = data.alignment; |
|
if (data1 !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data1 !== "string") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.alignment', |
|
schemaPath: '#/properties/alignment/type', |
|
params: { |
|
type: 'string' |
|
}, |
|
message: 'should be string' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var schema1 = validate.schema.properties.alignment.enum; |
|
var valid1; |
|
valid1 = false; |
|
for (var i1 = 0; i1 < schema1.length; i1++) |
|
if (equal(data1, schema1[i1])) { |
|
valid1 = true; |
|
break; |
|
} if (!valid1) { |
|
var err = { |
|
keyword: 'enum', |
|
dataPath: (dataPath || '') + '.alignment', |
|
schemaPath: '#/properties/alignment/enum', |
|
params: { |
|
allowedValues: schema1 |
|
}, |
|
message: 'should be equal to one of the allowed values' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.width !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data.width !== "number") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.width', |
|
schemaPath: '#/properties/width/type', |
|
params: { |
|
type: 'number' |
|
}, |
|
message: 'should be number' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.wrapWord !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data.wrapWord !== "boolean") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.wrapWord', |
|
schemaPath: '#/properties/wrapWord/type', |
|
params: { |
|
type: 'boolean' |
|
}, |
|
message: 'should be boolean' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.truncate !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data.truncate !== "number") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.truncate', |
|
schemaPath: '#/properties/truncate/type', |
|
params: { |
|
type: 'number' |
|
}, |
|
message: 'should be number' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.paddingLeft !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data.paddingLeft !== "number") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.paddingLeft', |
|
schemaPath: '#/properties/paddingLeft/type', |
|
params: { |
|
type: 'number' |
|
}, |
|
message: 'should be number' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.paddingRight !== undefined) { |
|
var errs_1 = errors; |
|
if (typeof data.paddingRight !== "number") { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + '.paddingRight', |
|
schemaPath: '#/properties/paddingRight/type', |
|
params: { |
|
type: 'number' |
|
}, |
|
message: 'should be number' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
} else { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/type', |
|
params: { |
|
type: 'object' |
|
}, |
|
message: 'should be object' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
validate.errors = vErrors; |
|
return errors === 0; |
|
}; |
|
})(); |
|
refVal4.schema = { |
|
"type": "object", |
|
"properties": { |
|
"alignment": { |
|
"type": "string", |
|
"enum": ["left", "right", "center"] |
|
}, |
|
"width": { |
|
"type": "number" |
|
}, |
|
"wrapWord": { |
|
"type": "boolean" |
|
}, |
|
"truncate": { |
|
"type": "number" |
|
}, |
|
"paddingLeft": { |
|
"type": "number" |
|
}, |
|
"paddingRight": { |
|
"type": "number" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}; |
|
refVal4.errors = null; |
|
refVal[4] = refVal4; |
|
return function validate(data, dataPath, parentData, parentDataProperty, rootData) { |
|
'use strict'; /*# sourceURL=config.json */ |
|
var vErrors = null; |
|
var errors = 0; |
|
if (rootData === undefined) rootData = data; |
|
if ((data && typeof data === "object" && !Array.isArray(data))) { |
|
var errs__0 = errors; |
|
var valid1 = true; |
|
for (var key0 in data) { |
|
var isAdditional0 = !(false || key0 == 'border' || key0 == 'columns' || key0 == 'columnDefault' || key0 == 'drawHorizontalLine'); |
|
if (isAdditional0) { |
|
valid1 = false; |
|
var err = { |
|
keyword: 'additionalProperties', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/additionalProperties', |
|
params: { |
|
additionalProperty: '' + key0 + '' |
|
}, |
|
message: 'should NOT have additional properties' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
} |
|
if (data.border !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal1(data.border, (dataPath || '') + '.border', data, 'border', rootData)) { |
|
if (vErrors === null) vErrors = refVal1.errors; |
|
else vErrors = vErrors.concat(refVal1.errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.columns !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal3(data.columns, (dataPath || '') + '.columns', data, 'columns', rootData)) { |
|
if (vErrors === null) vErrors = refVal3.errors; |
|
else vErrors = vErrors.concat(refVal3.errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.columnDefault !== undefined) { |
|
var errs_1 = errors; |
|
if (!refVal[4](data.columnDefault, (dataPath || '') + '.columnDefault', data, 'columnDefault', rootData)) { |
|
if (vErrors === null) vErrors = refVal[4].errors; |
|
else vErrors = vErrors.concat(refVal[4].errors); |
|
errors = vErrors.length; |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
if (data.drawHorizontalLine !== undefined) { |
|
var errs_1 = errors; |
|
var errs__1 = errors; |
|
var valid1; |
|
valid1 = typeof data.drawHorizontalLine == "function"; |
|
if (!valid1) { |
|
if (errs__1 == errors) { |
|
var err = { |
|
keyword: 'typeof', |
|
dataPath: (dataPath || '') + '.drawHorizontalLine', |
|
schemaPath: '#/properties/drawHorizontalLine/typeof', |
|
params: { |
|
keyword: 'typeof' |
|
}, |
|
message: 'should pass "typeof" keyword validation' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} else { |
|
for (var i1 = errs__1; i1 < errors; i1++) { |
|
var ruleErr1 = vErrors[i1]; |
|
if (ruleErr1.dataPath === undefined) ruleErr1.dataPath = (dataPath || '') + '.drawHorizontalLine'; |
|
if (ruleErr1.schemaPath === undefined) { |
|
ruleErr1.schemaPath = "#/properties/drawHorizontalLine/typeof"; |
|
} |
|
} |
|
} |
|
} |
|
var valid1 = errors === errs_1; |
|
} |
|
} else { |
|
var err = { |
|
keyword: 'type', |
|
dataPath: (dataPath || '') + "", |
|
schemaPath: '#/type', |
|
params: { |
|
type: 'object' |
|
}, |
|
message: 'should be object' |
|
}; |
|
if (vErrors === null) vErrors = [err]; |
|
else vErrors.push(err); |
|
errors++; |
|
} |
|
validate.errors = vErrors; |
|
return errors === 0; |
|
}; |
|
})(); |
|
validate.schema = { |
|
"$id": "config.json", |
|
"$schema": "http://json-schema.org/draft-07/schema#", |
|
"type": "object", |
|
"properties": { |
|
"border": { |
|
"$ref": "#/definitions/borders" |
|
}, |
|
"columns": { |
|
"$ref": "#/definitions/columns" |
|
}, |
|
"columnDefault": { |
|
"$ref": "#/definitions/column" |
|
}, |
|
"drawHorizontalLine": { |
|
"typeof": "function" |
|
} |
|
}, |
|
"additionalProperties": false, |
|
"definitions": { |
|
"columns": { |
|
"type": "object", |
|
"patternProperties": { |
|
"^[0-9]+$": { |
|
"$ref": "#/definitions/column" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}, |
|
"column": { |
|
"type": "object", |
|
"properties": { |
|
"alignment": { |
|
"type": "string", |
|
"enum": ["left", "right", "center"] |
|
}, |
|
"width": { |
|
"type": "number" |
|
}, |
|
"wrapWord": { |
|
"type": "boolean" |
|
}, |
|
"truncate": { |
|
"type": "number" |
|
}, |
|
"paddingLeft": { |
|
"type": "number" |
|
}, |
|
"paddingRight": { |
|
"type": "number" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}, |
|
"borders": { |
|
"type": "object", |
|
"properties": { |
|
"topBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"topRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bottomRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"bodyJoin": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinBody": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinLeft": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinRight": { |
|
"$ref": "#/definitions/border" |
|
}, |
|
"joinJoin": { |
|
"$ref": "#/definitions/border" |
|
} |
|
}, |
|
"additionalProperties": false |
|
}, |
|
"border": { |
|
"type": "string" |
|
} |
|
} |
|
}; |
|
validate.errors = null; |
|
module.exports = validate; |