@nextage/nx-frame-be 1.0.1

package/build/common/crypto/crypto.utils.d.ts

@@ -0,0 +1,139 @@
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { NxObject } from '../interfaces';
+import { BlindIndexOptions } from './crypto.interfaces';
+import { SymmetricKey, AsymmetricKeyPair } from './crypto.classes';
+export declare class CryptoUtils {
+    logger: any;
+    constructor();
+    /**
+     * Generate a random Symmetric key based on AES bit size specified
+     *
+     * @param { number } aesBitSize bit size used by AES algorithm (128/192/256)
+     * @returns { Promise<SymmetricKey> } Promise that resolve SymmetricKey
+     */
+    generateRndSymKey(aesBitSize: number): Promise<SymmetricKey>;
+    /**
+     * Generate Asymmetric keys (public/private) based on RSA algorithm modulus bit size
+     *
+     * @param { number } modLength bit size of modulus used by RSA algorithm (1024/2048/4096)
+     * @returns { Promise<AsymmetricKeyPair> } Promise that resolve KeyPairKeyObjectResult
+     */
+    generateAsymKeys(modLength: number): Promise<AsymmetricKeyPair>;
+    /**
+     * Cypher data by AES algorithm using given SymmetricKey object
+     *
+     * @param { SymmetricKey } keyObj
+     * @param { Stream | string } data
+     * @returns { Promise< Stream | string > } Promise that resolve Stream or string of cyphered data (Based on given Type of data )
+     */
+    cypherSym(keyObj: SymmetricKey, data: Stream | string): Promise<Stream | string>;
+    /**
+     * Decypher encripted data by AES algorithm using given SymmetricKey object
+     *
+     * @param { SymmetricKey } keyObj
+     * @param { Stream | string } encData
+     * @returns { Promise< Stream | string > } Promise that resolve Stream or string of decyphered data (Based on given Type of data)
+     */
+    decypherSym(keyObj: SymmetricKey, encData: Stream | string): Promise<Stream | string>;
+    /**
+     * Cypher data by RSA algorithm using public key string
+     *
+     * @param { string } publicKey
+     * @param { string } data
+     * @returns { Promise<string> } Promise that resolve string of publicKey cyphered data
+     */
+    cypherAsym(publicKey: string, data: string): Promise<string>;
+    /**
+     * Decypher encrypted (public key) data by RSA algorithm using private key string
+     *
+     * @param { string } privateKey
+     * @param {*} encData
+     * @returns { Promise<string> } Promise that resolve string of privateKey decyphered data
+     */
+    decypherAsym(privateKey: string, encData: string): Promise<string>;
+    /**
+     * Decrypt AES encrypted string using CryptoJs
+     *
+     * @param   { string } text AES encrypted string to be decrypted
+     * @param   { string } secret Secret string to decrypt value
+     * @returns { string } Decrypted value
+     */
+    decryptText(text: string, secret: string): string;
+    /**
+     * Encrypt plain text string to AES using CryptoJS
+     *
+     * @param   { string } text Plain text string to be AES encrypted
+     * @param   { string } secret Secret string to encrypt value
+     * @returns { string } Encrypted value
+     */
+    encryptText(text: string, secret: string): string;
+    /**
+     * Generate an md5 hash from given string
+     *
+     * @param {string} text
+     */
+    md5(text: string): string;
+    /**
+     *
+     * @param {*} text
+     * @returns
+     */
+    sha256(text: string): string;
+    /**
+     *
+     * @param {*} text
+     * @returns
+     */
+    sha512(text: string): string;
+    /**
+     * Encrypt a text to PBKDF2 derivation function using given salt and keysize
+     *
+     * @param { string } text
+     * @param { string } salt
+     * @param { number} keySize default 256
+     * @return { string } Hashed value
+     */
+    pbkdf2(text: string, salt: string, keySize?: number, hasher?: any, iterations?: number): string;
+    /**
+     * Encrypt a text to PBKDF2 derivation function using given salt and keysize
+     *
+     * @param { string } text
+     * @param { string } salt
+     * @param { number} keylen default 8
+     * @param { number} iterations default 10000
+     * @param { string} digest default sha256
+     * @return { string } Hashed value
+     */
+    pbkdf2Node(text: string, salt: string, keylen?: number, iterations?: number, digest?: string): string;
+    /**
+     *
+     * @param {*} item
+     * @param {*} keys
+     */
+    encryptSearchableFields(item: NxObject | undefined, keys: string[] | undefined, salts: string[], secret: string, opts: BlindIndexOptions): void;
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    encryptSearchableField(item: NxObject, key: string, salt: string, secret: string, opts: BlindIndexOptions): void;
+    /**
+     *
+     * @param {*} item
+     * @param {*} keys
+     */
+    createBlindIndexes(item: NxObject | undefined, keys: string[] | undefined, secret: string, opts?: BlindIndexOptions): void;
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    createBlindIndex(item: NxObject, key: string, salt: string, { hasher, iterations, keySize, normalize }?: BlindIndexOptions): void;
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    getBlindIndex(item: NxObject, key: string): string;
+}

package/build/common/crypto/crypto.utils.js

@@ -0,0 +1,380 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoUtils = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const stream_1 = require("stream");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils");
+const crypto_constants_1 = require("./crypto.constants");
+const crypto_constants_2 = require("./crypto.constants");
+const crypto_constants_3 = require("./crypto.constants");
+const crypto_constants_4 = require("./crypto.constants");
+const crypto_constants_5 = require("./crypto.constants");
+const crypto_classes_1 = require("./crypto.classes");
+class CryptoUtils {
+    constructor() {
+        this.logger = constants_1.APP.logger;
+    }
+    /**
+     * Generate a random Symmetric key based on AES bit size specified
+     *
+     * @param { number } aesBitSize bit size used by AES algorithm (128/192/256)
+     * @returns { Promise<SymmetricKey> } Promise that resolve SymmetricKey
+     */
+    generateRndSymKey(aesBitSize) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'generateRndSymKey');
+        return new Promise((resolve, reject) => {
+            try {
+                if (!crypto_constants_1.CRYPTO_SYM_BITSIZE_MAP[aesBitSize]) {
+                    // TODO
+                    const error = crypto_constants_5.CRYPTO_ERRORS.SYM_BITSIZE;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+                const { keySize, ivSize, saltSize, phraseSize } = crypto_constants_1.CRYPTO_SYM_BITSIZE_MAP[aesBitSize];
+                const ivBuffer = (0, utils_2.generateRandomBuffer)(ivSize);
+                const salt = (0, utils_2.generateRandomBuffer)(saltSize).toString('hex');
+                const phrase = (0, utils_2.generateRandomBuffer)(phraseSize).toString('hex');
+                const keySizeBytes = keySize / 8;
+                const keyBuffer = crypto_1.default.scryptSync(phrase, salt, keySizeBytes);
+                const symKey = new crypto_classes_1.SymmetricKey({ key: keyBuffer.toString('base64'), iv: ivBuffer.toString('base64'), size: aesBitSize });
+                resolve(symKey);
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.SYM_KEYGEN };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Generate Asymmetric keys (public/private) based on RSA algorithm modulus bit size
+     *
+     * @param { number } modLength bit size of modulus used by RSA algorithm (1024/2048/4096)
+     * @returns { Promise<AsymmetricKeyPair> } Promise that resolve KeyPairKeyObjectResult
+     */
+    generateAsymKeys(modLength) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'generateAsymKeys');
+        return new Promise((resolve, reject) => {
+            try {
+                if (!(crypto_constants_4.CRYPTO_ASYM_BITSIZE_LIST.includes(modLength))) {
+                    const error = crypto_constants_5.CRYPTO_ERRORS.ASYM_BITSIZE;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+                const options = { modulusLength: modLength, publicKeyEncoding: crypto_constants_2.CRYPTO_PUB_KEY_ENCODING, privateKeyEncoding: crypto_constants_3.CRYPTO_PRIV_KEY_ENCODING };
+                const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync('rsa', options);
+                const keyPair = new crypto_classes_1.AsymmetricKeyPair({ publicKey, privateKey });
+                resolve(keyPair);
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.ASYM_KEYGEN };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Cypher data by AES algorithm using given SymmetricKey object
+     *
+     * @param { SymmetricKey } keyObj
+     * @param { Stream | string } data
+     * @returns { Promise< Stream | string > } Promise that resolve Stream or string of cyphered data (Based on given Type of data )
+     */
+    cypherSym(keyObj, data) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'cypherSym');
+        return new Promise((resolve, reject) => {
+            try {
+                const key = Buffer.from(keyObj.key, 'base64');
+                const iv = Buffer.from(keyObj.iv, 'base64');
+                const algorithm = `aes${keyObj.size}`;
+                const cypher = crypto_1.default.createCipheriv(algorithm, key, iv);
+                if (data instanceof stream_1.Stream)
+                    resolve(data.pipe(cypher));
+                else if ((0, utils_2.isString)(data)) {
+                    let encrypted = cypher.update(data, 'utf8', 'hex');
+                    encrypted += cypher.final('hex');
+                    resolve(encrypted);
+                }
+                else {
+                    const error = crypto_constants_5.CRYPTO_ERRORS.SYM_DATA_TYPE;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.SYM_ENC };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Decypher encripted data by AES algorithm using given SymmetricKey object
+     *
+     * @param { SymmetricKey } keyObj
+     * @param { Stream | string } encData
+     * @returns { Promise< Stream | string > } Promise that resolve Stream or string of decyphered data (Based on given Type of data)
+     */
+    decypherSym(keyObj, encData) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'decypherSym');
+        return new Promise((resolve, reject) => {
+            try {
+                const key = Buffer.from(keyObj.key, 'base64');
+                const iv = Buffer.from(keyObj.iv, 'base64');
+                const algorithm = `aes${keyObj.size}`;
+                const decypher = crypto_1.default.createDecipheriv(algorithm, key, iv);
+                if (encData instanceof stream_1.Stream)
+                    resolve(encData.pipe(decypher));
+                else if ((0, utils_2.isString)(encData)) {
+                    let decrypted = decypher.update(encData, 'hex', 'utf8');
+                    decrypted += decypher.final('utf8');
+                    resolve(decrypted);
+                }
+                else {
+                    const error = crypto_constants_5.CRYPTO_ERRORS.SYM_DATA_TYPE;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.SYM_DEC };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Cypher data by RSA algorithm using public key string
+     *
+     * @param { string } publicKey
+     * @param { string } data
+     * @returns { Promise<string> } Promise that resolve string of publicKey cyphered data
+     */
+    cypherAsym(publicKey, data) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'cypherAsym');
+        return new Promise((resolve, reject) => {
+            try {
+                if (!publicKey || !data) {
+                    const error = crypto_constants_5.CRYPTO_ERRORS.ASYM_PUB_ARGS;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+                const pubEncrypted = crypto_1.default.publicEncrypt(publicKey, Buffer.from(data)).toString('base64');
+                resolve(pubEncrypted);
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.ASYM_ENC };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Decypher encrypted (public key) data by RSA algorithm using private key string
+     *
+     * @param { string } privateKey
+     * @param {*} encData
+     * @returns { Promise<string> } Promise that resolve string of privateKey decyphered data
+     */
+    decypherAsym(privateKey, encData) {
+        const logCtx = (0, utils_1.logClassCtx)(this, 'decypherAsym');
+        return new Promise((resolve, reject) => {
+            try {
+                if (!privateKey || !encData) {
+                    const error = crypto_constants_5.CRYPTO_ERRORS.ASYM_PRIV_ARGS;
+                    this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                    reject(error);
+                }
+                const privDecrypted = crypto_1.default.privateDecrypt(privateKey, Buffer.from(encData, 'base64')).toString();
+                resolve(privDecrypted);
+            }
+            catch (err) {
+                const error = { message: err, code: crypto_constants_5.CRYPTO_ERR_CODES.ASYM_DEC };
+                this.logger.error(`[${error.code}] ${error.message}`, logCtx);
+                reject(error);
+            }
+        });
+    }
+    // --------------------------------------------------------- CRYPTO-JS METHODS ---------------------------------------------------------------------------
+    /**
+     * Decrypt AES encrypted string using CryptoJs
+     *
+     * @param   { string } text AES encrypted string to be decrypted
+     * @param   { string } secret Secret string to decrypt value
+     * @returns { string } Decrypted value
+     */
+    decryptText(text, secret) {
+        if (!text || !secret)
+            return '';
+        return crypto_js_1.default.AES.decrypt(text, secret).toString(crypto_js_1.default.enc.Utf8);
+    }
+    /**
+     * Encrypt plain text string to AES using CryptoJS
+     *
+     * @param   { string } text Plain text string to be AES encrypted
+     * @param   { string } secret Secret string to encrypt value
+     * @returns { string } Encrypted value
+     */
+    encryptText(text, secret) {
+        if (!text || !secret)
+            return '';
+        return crypto_js_1.default.AES.encrypt(text, secret).toString();
+    }
+    /**
+     * Generate an md5 hash from given string
+     *
+     * @param {string} text
+     */
+    md5(text) {
+        if (!text)
+            return '';
+        return crypto_js_1.default.MD5(text).toString();
+    }
+    /**
+     *
+     * @param {*} text
+     * @returns
+     */
+    sha256(text) {
+        if (!text)
+            return '';
+        return crypto_js_1.default.SHA256(text).toString();
+    }
+    /**
+     *
+     * @param {*} text
+     * @returns
+     */
+    sha512(text) {
+        if (!text)
+            return '';
+        return crypto_js_1.default.SHA512(text).toString();
+    }
+    /**
+     * Encrypt a text to PBKDF2 derivation function using given salt and keysize
+     *
+     * @param { string } text
+     * @param { string } salt
+     * @param { number} keySize default 256
+     * @return { string } Hashed value
+     */
+    pbkdf2(text, salt, keySize = 256, hasher = crypto_js_1.default.algo.SHA256, iterations = 10000) {
+        if (!text || !salt)
+            return '';
+        return crypto_js_1.default.PBKDF2(text, salt, { keySize: keySize / 32, hasher, iterations }).toString();
+    }
+    /**
+     * Encrypt a text to PBKDF2 derivation function using given salt and keysize
+     *
+     * @param { string } text
+     * @param { string } salt
+     * @param { number} keylen default 8
+     * @param { number} iterations default 10000
+     * @param { string} digest default sha256
+     * @return { string } Hashed value
+     */
+    pbkdf2Node(text, salt, keylen = 8, iterations = 10000, digest = 'sha256') {
+        if (!text || !salt)
+            return '';
+        return crypto_1.default.pbkdf2Sync(text, salt, iterations, keylen, digest).toString('hex');
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} keys
+     */
+    encryptSearchableFields(item = {}, keys = [], salts, secret, opts) {
+        keys.forEach((k, index) => this.encryptSearchableField(item, k, salts && salts[index], secret, opts));
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    encryptSearchableField(item, key, salt, secret, opts) {
+        if (!item || !key)
+            return;
+        let value = (0, utils_1.getAttr)(item, key);
+        if (!value)
+            return;
+        this.createBlindIndex(item, key, salt, opts);
+        (0, utils_1.setAttr)(item, key, this.encryptText(value, secret).toString());
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} keys
+     */
+    createBlindIndexes(item = {}, keys = [], secret, opts = {}) {
+        keys.forEach(k => this.createBlindIndex(item, k, secret, opts));
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    createBlindIndex(item, key, salt, { hasher, iterations, keySize, normalize } = {}) {
+        let value = (0, utils_1.getAttr)(item, key);
+        if (!value)
+            return;
+        if (normalize)
+            value = `${value}`.toUpperCase();
+        (0, utils_1.setAttr)(item, `${key}_bidx`, this.pbkdf2(value, salt || key, keySize, hasher, iterations));
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} key
+     */
+    getBlindIndex(item, key) {
+        return (0, utils_1.getAttr)(item, `${key}_bidx`);
+    }
+}
+exports.CryptoUtils = CryptoUtils;
+//export const cryptoUtils = new CryptoUtils();
+// FOR TESTING PURPOSE ONLY
+/* (function () {
+  function error(err) {
+    debugger;
+    return this.logger.error(err);
+  }
+  debugger;
+  cryptoUtils.generateRndSymKey().catch(err => {
+    
+    
+    this.logger.warn('-------------START-CRYPTO_UTILS-ERROR-TESTING--------------');
+    this.logger.info('----------- generateRndSymKey ------------------');
+    error(err);
+  })
+    .finally(() => {
+      this.logger.info('----------- generateAsymKeys ------------------');
+      cryptoUtils.generateAsymKeys().catch(error)
+      .finally(() => {
+        this.logger.info('----------- cypherSym ------------------');
+        const salt   = generateRandomBuffer(32).toString('hex');
+        const phrase = generateRandomBuffer(128).toString('hex');
+        
+        const key = { key: crypto.scryptSync(phrase, salt, 256), size:256, iv: generateRandomBuffer(162)};
+        cryptoUtils.cypherSym(key, new Stream('asd')).catch(error)
+        .finally(() => {
+          this.logger.info('----------- decypherSym ------------------');
+          cryptoUtils.decypherSym({}, new Stream('asd')).catch(error)
+          .finally(() => {
+            this.logger.info('----------- cypherAsym ------------------');
+            cryptoUtils.cypherAsym('', 'asdasdasddas').catch(error)
+            .finally(() => {
+              this.logger.info('----------- cypherAsym ------------------');
+              cryptoUtils.decypherAsym(' ', 'asdasdasdas').catch(error)
+              .finally(() =>  this.logger.warn('-------------END-CRYPTO_UTILS-ERROR-TESTING--------------'))
+            })
+          })
+        })
+      })
+    })
+  })(); */

package/build/common/crypto/index.d.ts

@@ -0,0 +1,3 @@
+export * from './crypto.interfaces';
+export * from './crypto.classes';
+export * from './crypto.utils';

package/build/common/crypto/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./crypto.interfaces"), exports);
+__exportStar(require("./crypto.classes"), exports);
+__exportStar(require("./crypto.utils"), exports);

package/build/common/enums.d.ts

@@ -0,0 +1,61 @@
+export declare enum AppMode {
+    DEV = "development",
+    PROD = "production"
+}
+export declare enum AppStatus {
+    INIT = "INIT",
+    OK = "OK"
+}
+export declare enum ModelCrudEventType {
+    create = "create",
+    update = "update",
+    remove = "remove",
+    addArrayItem = "addArrayItem",
+    updateArrayItem = "updateArrayItem",
+    removeArrayItem = "removeArrayItem"
+}
+export declare enum DatePeriod {
+    WEEK = "week",
+    MONTH = "month",
+    QUARTER_1 = "quarter1",
+    QUARTER_2 = "quarter2",
+    QUARTER_3 = "quarter3",
+    QUARTER_4 = "quarter4",
+    SEMESTER_1 = "semester1",
+    SEMESTER_2 = "semester2",
+    YEAR = "year",
+    CURR_WEEK = "currweek",
+    CURR_MONTH = "currmonth",
+    CURR_QUARTER = "currquarter",
+    CURR_SEMESTER = "currsemester",
+    CURR_YEAR = "curryear",
+    LAST_WEEK = "lastweek",
+    LAST_MONTH = "lastmonth",
+    LAST_QUARTER = "lastquarter",
+    LAST_SEMESTER = "lastsemester",
+    LAST_YEAR = "lastyear"
+}
+export declare enum ValueType {
+    BADGE = "badge",
+    CURRENCY = "currency",
+    DATE = "date",
+    DATETIME = "datetime",
+    DECIMAL = "decimal",
+    EMAIL = "email",
+    FILESIZE = "filesize",
+    HTML = "html",
+    ICON = "icon",
+    LINK = "link",
+    NUMBER = "number",
+    PERCENTAGE = "percentage",
+    PROGRESS = "progress",
+    SELECT = "select",
+    STRING = "string",
+    STRING_WRAP = "stringwrap",
+    SWITCH = "switch",
+    BOOLEAN = "boolean"
+}
+export declare enum AuthIssuer {
+    USER = "user",
+    DEVICE = "device"
+}

package/build/common/enums.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthIssuer = exports.ValueType = exports.DatePeriod = exports.ModelCrudEventType = exports.AppStatus = exports.AppMode = void 0;
+var AppMode;
+(function (AppMode) {
+    AppMode["DEV"] = "development";
+    AppMode["PROD"] = "production";
+})(AppMode || (exports.AppMode = AppMode = {}));
+;
+var AppStatus;
+(function (AppStatus) {
+    AppStatus["INIT"] = "INIT";
+    AppStatus["OK"] = "OK";
+})(AppStatus || (exports.AppStatus = AppStatus = {}));
+;
+var ModelCrudEventType;
+(function (ModelCrudEventType) {
+    ModelCrudEventType["create"] = "create";
+    ModelCrudEventType["update"] = "update";
+    ModelCrudEventType["remove"] = "remove";
+    ModelCrudEventType["addArrayItem"] = "addArrayItem";
+    ModelCrudEventType["updateArrayItem"] = "updateArrayItem";
+    ModelCrudEventType["removeArrayItem"] = "removeArrayItem";
+})(ModelCrudEventType || (exports.ModelCrudEventType = ModelCrudEventType = {}));
+;
+var DatePeriod;
+(function (DatePeriod) {
+    DatePeriod["WEEK"] = "week";
+    DatePeriod["MONTH"] = "month";
+    DatePeriod["QUARTER_1"] = "quarter1";
+    DatePeriod["QUARTER_2"] = "quarter2";
+    DatePeriod["QUARTER_3"] = "quarter3";
+    DatePeriod["QUARTER_4"] = "quarter4";
+    DatePeriod["SEMESTER_1"] = "semester1";
+    DatePeriod["SEMESTER_2"] = "semester2";
+    DatePeriod["YEAR"] = "year";
+    DatePeriod["CURR_WEEK"] = "currweek";
+    DatePeriod["CURR_MONTH"] = "currmonth";
+    DatePeriod["CURR_QUARTER"] = "currquarter";
+    DatePeriod["CURR_SEMESTER"] = "currsemester";
+    DatePeriod["CURR_YEAR"] = "curryear";
+    DatePeriod["LAST_WEEK"] = "lastweek";
+    DatePeriod["LAST_MONTH"] = "lastmonth";
+    DatePeriod["LAST_QUARTER"] = "lastquarter";
+    DatePeriod["LAST_SEMESTER"] = "lastsemester";
+    DatePeriod["LAST_YEAR"] = "lastyear";
+})(DatePeriod || (exports.DatePeriod = DatePeriod = {}));
+;
+var ValueType;
+(function (ValueType) {
+    ValueType["BADGE"] = "badge";
+    ValueType["CURRENCY"] = "currency";
+    ValueType["DATE"] = "date";
+    ValueType["DATETIME"] = "datetime";
+    ValueType["DECIMAL"] = "decimal";
+    ValueType["EMAIL"] = "email";
+    ValueType["FILESIZE"] = "filesize";
+    ValueType["HTML"] = "html";
+    ValueType["ICON"] = "icon";
+    ValueType["LINK"] = "link";
+    ValueType["NUMBER"] = "number";
+    ValueType["PERCENTAGE"] = "percentage";
+    ValueType["PROGRESS"] = "progress";
+    ValueType["SELECT"] = "select";
+    ValueType["STRING"] = "string";
+    ValueType["STRING_WRAP"] = "stringwrap";
+    ValueType["SWITCH"] = "switch";
+    ValueType["BOOLEAN"] = "boolean";
+})(ValueType || (exports.ValueType = ValueType = {}));
+;
+var AuthIssuer;
+(function (AuthIssuer) {
+    AuthIssuer["USER"] = "user";
+    AuthIssuer["DEVICE"] = "device";
+})(AuthIssuer || (exports.AuthIssuer = AuthIssuer = {}));