structured-fw 0.7.2

package/build/system/server/Component.js

@@ -0,0 +1,249 @@
+import { Document } from './Document.js';
+import { attributeValueFromString, attributeValueToString, objectEach, toCamelCase } from '../Util.js';
+import { DOMFragment } from './dom/DOMFragment.js';
+export class Component {
+    constructor(name, node, parent, autoInit = true) {
+        this.children = [];
+        this.path = [];
+        this.attributesRaw = {};
+        this.attributes = {};
+        this.data = {};
+        this.name = name;
+        if (name === 'root') {
+            this.dom = new DOMFragment();
+            this.path.push('');
+            this.isRoot = true;
+        }
+        else {
+            this.dom = node || new DOMFragment();
+            if (parent) {
+                this.path = parent.path.concat(this.name);
+            }
+            this.isRoot = false;
+        }
+        if (this instanceof Document) {
+            this.document = this;
+        }
+        else {
+            if (!(parent instanceof Component)) {
+                console.error('Component initialized without a parent');
+            }
+            this.document = parent.document;
+        }
+        this.parent = parent || null;
+        this.id = '';
+        const component = parent === undefined ? false : this.document.application.components.getByName(this.name);
+        if (component) {
+            this.entry = component;
+            if (autoInit) {
+                this.init(component.html);
+            }
+        }
+        else {
+            this.entry = null;
+        }
+    }
+    async init(html, data) {
+        this.initAttributesData();
+        this.dom.tagName = this.entry?.renderTagName || 'div';
+        this.dom.innerHTML = html;
+        this.setAttributes(this.attributesRaw, '', false);
+        if (this.entry !== null && this.entry.initializer !== undefined && typeof this.document.initializers[this.name] === 'undefined') {
+            this.document.initializers[this.name] = this.entry.initializer;
+        }
+        this.dom.setAttribute(`data-${this.document.application.config.components.componentNameAttribute}`, this.name);
+        if (typeof this.attributes.componentId !== 'string') {
+            this.id = this.document.allocateId(this);
+            this.dom.setAttribute('data-component-id', this.id);
+        }
+        else {
+            this.id = this.attributes.componentId;
+        }
+        const exportedContextData = this.document.application.exportedRequestContextData.reduce((prev, field) => {
+            if (!this.document.ctx) {
+                return prev;
+            }
+            if (field in this.document.ctx.data) {
+                prev[field] = this.document.ctx.data[field];
+            }
+            return prev;
+        }, {});
+        objectEach(exportedContextData, (key, val) => {
+            if (this.document.application.exportedRequestContextData.includes(key)) {
+                this.setAttributes({ [key]: val }, 'data-', true);
+            }
+        });
+        this.data = exportedContextData;
+        if (this.entry !== null &&
+            typeof this.entry.module !== 'undefined' &&
+            typeof this.entry.module.deferred === 'function' &&
+            this.entry.module.deferred(this.attributes, this.document.ctx, this.document.application) &&
+            this.attributes.deferred !== false) {
+            this.setAttributes({ deferred: true }, 'data-', true);
+            return;
+        }
+        if (typeof this.attributes.use === 'string' && this.parent !== null) {
+            this.attributes = Object.assign(this.importedParentData(this.parent.data) || {}, this.attributes);
+        }
+        if (data === undefined) {
+            if (this.entry && this.entry.module) {
+                this.data = Object.assign(this.data, await this.entry.module.getData(this.attributes, this.document.ctx, this.document.application, this) || {});
+            }
+            else {
+                this.data = Object.assign(exportedContextData, this.attributes);
+            }
+        }
+        else {
+            this.data = Object.assign(exportedContextData, data, this.attributes);
+        }
+        this.fillData(this.data);
+        if (this.entry === null || this.entry.exportData) {
+            this.setAttributes(this.data, 'data-');
+        }
+        else if (this.entry) {
+            if (this.entry.exportFields) {
+                this.setAttributes(this.entry.exportFields.reduce((prev, field) => {
+                    if (this.data[field] !== undefined) {
+                        prev[field] = this.data[field];
+                    }
+                    return prev;
+                }, {}), 'data-');
+            }
+            if (this.entry.attributes) {
+                this.setAttributes(this.entry.attributes, '', false);
+            }
+        }
+        await this.initChildren();
+        if (this.isRoot) {
+            const dataIf = this.dom.queryByHasAttribute('data-if');
+            for (let i = 0; i < dataIf.length; i++) {
+                dataIf[i].style.display = 'none';
+            }
+        }
+    }
+    setAttributes(attributes, prefix = '', encode = true) {
+        if (typeof attributes === 'object' && attributes !== null) {
+            for (const attr in attributes) {
+                const encoded = typeof attributes[attr] === 'string' && attributes[attr].indexOf('base64:') === 0;
+                const value = (encode && !encoded) ? attributeValueToString(attr, attributes[attr]) : attributes[attr];
+                this.dom.setAttribute(prefix + attr, value);
+            }
+        }
+    }
+    async initChildren(passData) {
+        const componentTags = this.document.application.components.componentNames;
+        const childNodes = this.dom.queryByTagName(...componentTags);
+        for (let i = 0; i < childNodes.length; i++) {
+            const childNode = childNodes[i];
+            const component = this.document.application.components.getByName(childNode.tagName);
+            if (component) {
+                const child = new Component(component.name, childNode, this, false);
+                await child.init(childNode.outerHTML, passData);
+                this.children.push(child);
+            }
+        }
+    }
+    importedParentData(parentData) {
+        if (!this.parent) {
+            return {};
+        }
+        const data = {};
+        if (typeof this.attributes.use !== 'string') {
+            return data;
+        }
+        const usePaths = this.attributes.use.split(',').map((key) => {
+            return key.split(/\.|\[(\d+)\]/).filter((s) => { return s !== undefined && s.length > 0; }).map((s) => {
+                return /^\d+$/.test(s) ? parseInt(s) : s;
+            });
+        });
+        usePaths.forEach((dataPath) => {
+            let dataCurrent = parentData;
+            for (let i = 0; i < dataPath.length; i++) {
+                const segment = dataPath[i];
+                if (typeof dataCurrent[segment] === 'undefined') {
+                    dataCurrent = undefined;
+                    break;
+                }
+                dataCurrent = dataCurrent[segment];
+            }
+            const dataKey = dataPath[dataPath.length - 1];
+            data[dataKey] = dataCurrent;
+        });
+        if (usePaths.length == 1 && typeof usePaths[0][usePaths[0].length - 1] === 'number') {
+            return data[usePaths[0][usePaths[0].length - 1]];
+        }
+        return data;
+    }
+    initAttributesData(domNode) {
+        if (domNode === undefined) {
+            domNode = this.dom;
+        }
+        for (let i = 0; i < domNode.attributes.length; i++) {
+            const attrNameRaw = domNode.attributes[i].name;
+            const attrNameUnprefixed = this.attributeUnpreffixed(attrNameRaw);
+            if (attrNameUnprefixed.indexOf('data-') === 0) {
+                const attrDataType = this.attributeDataType(attrNameRaw);
+                const dataDecoded = attributeValueFromString(domNode.attributes[i].value.toString());
+                const valueEncoded = typeof dataDecoded === 'object';
+                let value = valueEncoded ? dataDecoded.value : dataDecoded;
+                const key = valueEncoded ? dataDecoded.key : toCamelCase(attrNameUnprefixed.substring(5));
+                if (!valueEncoded) {
+                    if (typeof value === 'string') {
+                        if (attrDataType === 'number') {
+                            value = parseFloat(value);
+                        }
+                        else if (attrDataType === 'boolean') {
+                            value = value === 'true' || value === '1';
+                        }
+                        else if (attrDataType === 'object') {
+                            if (typeof value === 'string') {
+                                if (value.trim().length > 1) {
+                                    value = JSON.parse(value);
+                                }
+                                else {
+                                    value = null;
+                                }
+                            }
+                        }
+                    }
+                    const attrData = attributeValueToString(key, value);
+                    domNode.setAttribute(attrNameRaw, attrData);
+                }
+                this.attributes[key] = value;
+            }
+            this.attributesRaw[attrNameRaw] = domNode.attributes[i].value;
+        }
+    }
+    attributePreffix(attrName) {
+        const index = attrName.indexOf(':');
+        if (index < 0) {
+            return null;
+        }
+        return attrName.substring(0, index);
+    }
+    attributeDataType(attrName) {
+        const prefix = this.attributePreffix(attrName);
+        if (prefix === 'string' ||
+            prefix === 'number' ||
+            prefix === 'object' ||
+            prefix === 'boolean') {
+            return prefix;
+        }
+        return 'any';
+    }
+    attributeUnpreffixed(attrName) {
+        const index = attrName.indexOf(':');
+        if (index < 0) {
+            return attrName;
+        }
+        return attrName.substring(index + 1);
+    }
+    fillData(data) {
+        if (this.entry && this.entry.static === true) {
+            this.dom.innerHTML = this.entry.html;
+            return;
+        }
+        const html = this.entry ? this.entry.html : this.dom.innerHTML;
+        this.dom.innerHTML = this.document.application.handlebars.compile(html, data);
+    }
+}

package/build/system/server/Components.d.ts

@@ -0,0 +1,12 @@
+import { ComponentEntry, StructuredConfig } from '../Types';
+import { Application } from './Application.js';
+export declare class Components {
+    config: StructuredConfig;
+    private readonly components;
+    componentNames: Array<string>;
+    constructor(app: Application);
+    loadComponents(relativeToPath?: string): void;
+    getByName(name: string): null | ComponentEntry;
+    private loadHTML;
+    private stripComments;
+}

package/build/system/server/Components.js

@@ -0,0 +1,77 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import * as path from 'node:path';
+export class Components {
+    constructor(app) {
+        this.components = {};
+        this.componentNames = [];
+        this.config = app.config;
+    }
+    loadComponents(relativeToPath) {
+        if (relativeToPath === undefined) {
+            relativeToPath = path.resolve((this.config.runtime === 'Node.js' ? '../' : './') + this.config.components.path);
+        }
+        const components = readdirSync(relativeToPath);
+        components.forEach(async (component) => {
+            const absolutePath = relativeToPath + '/' + component;
+            const isDirectory = statSync(absolutePath).isDirectory();
+            if (isDirectory) {
+                this.loadComponents(absolutePath);
+            }
+            else {
+                if (component.endsWith('.html') || component.endsWith('.hbs')) {
+                    const componentNameParts = component.split('.');
+                    const componentName = componentNameParts.slice(0, componentNameParts.length - 1).join('.');
+                    const pathAbsolute = relativeToPath || '';
+                    const pathRelative = path.relative(this.config.runtime === 'Node.js' ? '../' : './', pathAbsolute);
+                    const pathBuild = path.resolve('./' + pathRelative);
+                    const pathRelativeToViews = path.relative(`./${this.config.components.path}`, pathRelative);
+                    const pathHTML = `${pathAbsolute}/${component}`;
+                    const jsServerPath = `${pathBuild}/${componentName}.${this.config.runtime === 'Node.js' ? 'js' : 'ts'}`;
+                    const hasServerJS = existsSync(jsServerPath);
+                    const jsClientPath = `${pathBuild}/${componentName}.client.${this.config.runtime === 'Node.js' ? 'js' : 'ts'}`;
+                    const hasClientJS = existsSync(jsClientPath);
+                    const entry = {
+                        name: componentName,
+                        path: {
+                            absolute: pathAbsolute,
+                            relative: pathRelative,
+                            relativeToViews: `${pathRelativeToViews}/${component}`,
+                            build: pathBuild,
+                            html: pathHTML,
+                            jsClient: hasClientJS ? jsClientPath : undefined,
+                            jsServer: hasServerJS ? jsServerPath : undefined
+                        },
+                        hasJS: existsSync(jsServerPath),
+                        html: this.loadHTML(absolutePath),
+                        exportData: false,
+                        static: false
+                    };
+                    if (hasClientJS) {
+                        const initializer = await import('file:///' + jsClientPath);
+                        entry.initializer = initializer.init;
+                    }
+                    if (hasServerJS) {
+                        const componentConstructor = await import('file:///' + entry.path.jsServer);
+                        entry.module = new componentConstructor.default();
+                        entry.renderTagName = entry.module?.tagName || 'div';
+                        entry.exportData = typeof entry.module?.exportData === 'boolean' ? entry.module.exportData : false;
+                        entry.exportFields = entry.module?.exportFields;
+                        entry.attributes = entry.module?.attributes;
+                        entry.static = typeof entry.module?.static === 'boolean' ? entry.module.static : false;
+                    }
+                    this.components[componentName.toUpperCase()] = entry;
+                    this.componentNames.push(entry.name);
+                }
+            }
+        });
+    }
+    getByName(name) {
+        return this.components[name.toUpperCase()] || null;
+    }
+    loadHTML(path) {
+        return this.stripComments(readFileSync(path).toString());
+    }
+    stripComments(html) {
+        return html.replaceAll(/<!--(?!-?>)(?!.*--!>)(?!.*<!--(?!>)).*?(?<!<!-)-->/g, '');
+    }
+}

package/build/system/server/Cookies.d.ts

@@ -0,0 +1,6 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { LooseObject } from "../Types.js";
+export declare class Cookies {
+    parse(request: IncomingMessage): LooseObject;
+    set(response: ServerResponse, name: string, value: string | number, lifetimeSeconds: number, path?: string, sameSite?: 'Strict' | 'Lax' | 'None', domain?: string): void;
+}

package/build/system/server/Cookies.js

@@ -0,0 +1,19 @@
+export class Cookies {
+    parse(request) {
+        if (!request.headers.cookie) {
+            return {};
+        }
+        const cookieString = request.headers.cookie;
+        const cookiePairs = cookieString.split(';');
+        const cookies = {};
+        cookiePairs.forEach((cookiePair) => {
+            const parts = cookiePair.trim().split('=');
+            cookies[parts.shift() || ''] = parts.join('=');
+        });
+        return cookies;
+    }
+    set(response, name, value, lifetimeSeconds, path = '/', sameSite = 'Strict', domain) {
+        const expiresAt = lifetimeSeconds > 0 ? new Date(new Date().getTime() + lifetimeSeconds * 1000).toUTCString() : 0;
+        response.appendHeader('Set-Cookie', `${name}=${value}; Expires=${expiresAt}; Path=${path}; SameSite=${sameSite}${domain ? `; domain=${domain}` : ''}`);
+    }
+}

package/build/system/server/Document.d.ts

@@ -0,0 +1,24 @@
+import { ServerResponse } from 'node:http';
+import { Initializers, LooseObject, RequestContext } from '../../system/Types.js';
+import { Application } from './Application.js';
+import { DocumentHead } from './DocumentHead.js';
+import { Component } from './Component.js';
+export declare class Document extends Component {
+    head: DocumentHead;
+    language: string;
+    application: Application;
+    initializers: Initializers;
+    initializersInitialized: boolean;
+    componentIds: Array<string>;
+    ctx: undefined | RequestContext;
+    appendHTML: string;
+    constructor(app: Application, title: string, ctx?: RequestContext);
+    push(response: ServerResponse): void;
+    body(): string;
+    initInitializers(): Record<string, string>;
+    private initClientConfig;
+    toString(): string;
+    allocateId(component: Component): string;
+    loadView(pathRelative: string, data?: LooseObject): Promise<boolean>;
+    loadComponent(componentName: string, data?: LooseObject): Promise<void>;
+}

package/build/system/server/Document.js

@@ -0,0 +1,107 @@
+import { Md5 } from 'ts-md5';
+import { DocumentHead } from './DocumentHead.js';
+import { Component } from './Component.js';
+import { attributeValueToString, randomString } from '../Util.js';
+import path from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+export class Document extends Component {
+    constructor(app, title, ctx) {
+        super('root');
+        this.language = 'en';
+        this.initializers = {};
+        this.initializersInitialized = false;
+        this.componentIds = [];
+        this.appendHTML = '';
+        this.application = app;
+        this.ctx = ctx;
+        this.document = this;
+        this.head = new DocumentHead(title);
+        this.head.addJS('/assets/client-js/client/Client.js', 0, { type: 'module' });
+        this.application.emit('documentCreated', this);
+    }
+    push(response) {
+        const resourcesJS = this.head.js.map((resource) => {
+            return `<${resource.path}>; rel=${this.application.config.http.linkHeaderRel}; as=script; crossorigin=anonymous`;
+        });
+        const resourcesCSS = this.head.css.map((resource) => {
+            return `<${resource.path}>; rel=${this.application.config.http.linkHeaderRel}; as=style; crossorigin=anonymous`;
+        });
+        const value = resourcesCSS.concat(resourcesJS).join(', ');
+        response.setHeader('Link', value);
+    }
+    body() {
+        return this.dom.innerHTML + '\n' + this.appendHTML;
+    }
+    initInitializers() {
+        const initializers = {};
+        for (const name in this.initializers) {
+            initializers[name] = this.initializers[name].toString();
+        }
+        const initializersString = '<script type="application/javascript">window.initializers = ' + JSON.stringify(initializers) + '</script>';
+        this.head.add(initializersString);
+        this.initializersInitialized = true;
+        return initializers;
+    }
+    initClientConfig() {
+        const clientConf = {
+            componentRender: this.application.config.url.componentRender,
+            componentNameAttribute: this.application.config.components.componentNameAttribute
+        };
+        const clientConfString = `<script type="application/javascript">window.structuredClientConfig = ${JSON.stringify(clientConf)}</script>`;
+        this.head.add(clientConfString);
+    }
+    toString() {
+        if (!this.initializersInitialized) {
+            this.initInitializers();
+            this.initClientConfig();
+        }
+        return `<!DOCTYPE html>
+        <html lang="${this.language}">
+        ${this.head.toString()}
+        <body>
+            ${this.body()}
+        </body>
+        </html>`;
+    }
+    allocateId(component) {
+        if (!this.componentIds) {
+            this.componentIds = [];
+        }
+        let id = Md5.hashStr(`${component.name}:${'id' in component.attributes ? component.attributes.id : `${component.path.join('/')}:${JSON.stringify(component.attributesRaw)}`}`);
+        if (this.componentIds.includes(id)) {
+            let current = component.parent;
+            do {
+                if (current === null || current.isRoot) {
+                    console.error(`Could not define an unique ID for component ${component.name}, path: ${component.path}`);
+                    id = randomString(16);
+                }
+                else {
+                    id += '-' + Md5.hashStr(current.dom.outerHTML);
+                }
+                current = current?.parent || null;
+            } while (this.componentIds.includes(id));
+        }
+        this.componentIds.push(id);
+        return id;
+    }
+    async loadView(pathRelative, data) {
+        const viewPath = path.resolve('../' + this.application.config.components.path + '/' + pathRelative + (pathRelative.endsWith('.html') ? '' : '.html'));
+        if (!existsSync(viewPath)) {
+            console.warn(`Couldn't load document ${this.document.head.title}: ${viewPath}`);
+            return false;
+        }
+        const html = readFileSync(viewPath).toString();
+        await this.init(html, data);
+        return true;
+    }
+    async loadComponent(componentName, data) {
+        const componentEntry = this.document.application.components.getByName(componentName);
+        if (componentEntry) {
+            const dataString = data === undefined ? '' : Object.keys(data).reduce((prev, key) => {
+                prev.push(`data-${key}="${attributeValueToString(key, data[key])}"`);
+                return prev;
+            }, []).join(' ');
+            await this.init(`<${componentName} ${dataString}></${componentName}>`, data);
+        }
+    }
+}

package/build/system/server/DocumentHead.d.ts

@@ -0,0 +1,32 @@
+import { DocumentResource } from '../Types';
+export declare class DocumentHead {
+    title: string;
+    js: Array<DocumentResource>;
+    css: Array<DocumentResource>;
+    custom: Array<string>;
+    charset: string;
+    favicon: {
+        image: string | null;
+        type: string;
+    };
+    constructor(title: string);
+    setTitle(title: string): void;
+    add(str: string): void;
+    remove(str: string): void;
+    addJS(path: string, priority?: number, attributes?: {
+        [attributeName: string]: string | null;
+    }): DocumentResource;
+    addCSS(path: string, priority?: number, attributes?: {
+        [attributeName: string]: string | null;
+    }): DocumentResource;
+    removeJS(path: string): void;
+    removeCSS(path: string): void;
+    private toResource;
+    private attributesString;
+    toString(): string;
+    setFavicon(faviconPath: string | {
+        image: string | null;
+        type: string;
+    }): void;
+    private faviconType;
+}

package/build/system/server/DocumentHead.js

@@ -0,0 +1,118 @@
+export class DocumentHead {
+    constructor(title) {
+        this.js = [];
+        this.css = [];
+        this.custom = [];
+        this.charset = 'UTF-8';
+        this.favicon = {
+            image: null,
+            type: 'image/png'
+        };
+        this.title = title;
+    }
+    setTitle(title) {
+        this.title = title;
+    }
+    add(str) {
+        this.custom.push(str);
+    }
+    remove(str) {
+        this.custom = this.custom.filter((strExisting) => {
+            return strExisting !== str;
+        });
+    }
+    addJS(path, priority = 0, attributes = {}) {
+        const resource = this.toResource(path, priority, attributes);
+        this.js.push(resource);
+        return resource;
+    }
+    addCSS(path, priority = 0, attributes = {}) {
+        const resource = this.toResource(path, priority, attributes);
+        this.css.push(resource);
+        return resource;
+    }
+    removeJS(path) {
+        const index = this.js.findIndex((resource) => {
+            return resource.path == path;
+        });
+        this.js.splice(index, 1);
+    }
+    removeCSS(path) {
+        const index = this.css.findIndex((resource) => {
+            return resource.path == path;
+        });
+        this.css.splice(index, 1);
+    }
+    toResource(path, priority = 0, attributes = {}) {
+        return {
+            path,
+            priority,
+            attributes
+        };
+    }
+    attributesString(resource) {
+        let attributesString = '';
+        for (const attributeName in resource.attributes) {
+            const val = resource.attributes[attributeName];
+            if (val === null) {
+                attributesString += ` ${attributeName}`;
+            }
+            else {
+                attributesString += ` ${attributeName}="${val}"`;
+            }
+        }
+        return attributesString;
+    }
+    toString() {
+        const css = this.css.reduce((prev, curr) => {
+            return prev + '\n' + `<link rel="stylesheet" href="${curr.path}"${this.attributesString(curr)}>`;
+        }, '');
+        const js = this.js.reduce((prev, curr) => {
+            return prev + '\n' + `<script src="${curr.path}"${this.attributesString(curr)}></script>`;
+        }, '');
+        const custom = this.custom.reduce((prev, curr) => {
+            return prev + '\n' + curr;
+        }, '');
+        return `<head>
+            <meta charset="${this.charset}">
+            <meta http-equiv="X-UA-Compatible" content="IE=edge">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>${this.title}</title>
+            <link rel="icon" type="${this.favicon.type}" href="${this.favicon.image}">
+            ${css}
+            ${js}
+            ${custom}
+        </head>`;
+    }
+    setFavicon(faviconPath) {
+        if (typeof faviconPath === 'string') {
+            this.favicon = {
+                image: faviconPath,
+                type: this.faviconType(faviconPath)
+            };
+            return;
+        }
+        if (faviconPath.type === '') {
+            faviconPath.type = faviconPath.image ? this.faviconType(faviconPath.image) : 'image/png';
+        }
+        this.favicon = faviconPath;
+    }
+    faviconType(file) {
+        let ext = /\.([^.]+)$/.exec(file);
+        let type = 'image/png';
+        if (ext !== null) {
+            ext = ext[1].toLowerCase();
+            const types = {
+                'png': 'image/png',
+                'jpg': 'image/jpeg',
+                'jpeg': 'image/jpeg',
+                'gif': 'image/gif',
+                'ico': 'image/x-icon'
+            };
+            if (types[ext]) {
+                type = types[ext];
+            }
+        }
+        return type;
+    }
+}

package/build/system/server/FormValidation.d.ts

@@ -0,0 +1,16 @@
+import { FormValidationEntry, PostedDataDecoded, ValidationResult, ValidationRuleWithArguments, ValidatorErrorDecorator, ValidatorFunction } from '../Types';
+export declare class FormValidation {
+    fieldRules: Array<FormValidationEntry>;
+    singleError: boolean;
+    validators: {
+        [name: string]: ValidatorFunction;
+    };
+    decorators: {
+        [validatorName: string]: ValidatorErrorDecorator;
+    };
+    addRule(fieldName: string, nameHumanReadable: string, rules: Array<string | ValidationRuleWithArguments | ValidatorFunction>): void;
+    registerValidator(name: string, validator: ValidatorFunction, decorator?: ValidatorErrorDecorator): void;
+    registerDecorator(name: string, decorator: ValidatorErrorDecorator): void;
+    validate(data: PostedDataDecoded): Promise<ValidationResult>;
+    private addError;
+}