@questwork/q-utilities 0.1.29 → 0.1.32

package/dist/q-utilities.d.ts

@@ -0,0 +1,1035 @@
+export declare class ActionRecord {
+    static get _classname(): string;
+    static get _superclass(): string;
+    static dummyData(): {
+        timestamp: number;
+    };
+    static init(options?: {}): any;
+    constructor(options: any);
+    _Actor: any;
+    _actor: any;
+    actorCode: any;
+    timestamp: any;
+    get _classname(): string;
+    get _superclass(): string;
+    get actor(): any;
+    get isValid(): boolean;
+    update(update: any): this;
+}
+
+export declare class ApiResponse {
+    static init(options?: {}): ApiResponse;
+    static get _classname(): string;
+    static get _superclass(): string;
+    constructor(options?: {});
+    _data: any;
+    err: any;
+    isNew: any;
+    message: any;
+    total: any;
+    _instanceBuilder: any;
+    get data(): any;
+}
+
+export declare function authorize({ allowCoordinator, allowOwner, query, required, user }: {
+    allowCoordinator: any;
+    allowOwner: any;
+    query?: {};
+    required: any;
+    user: any;
+}): {};
+
+export declare class AwsStsS3Client {
+    static dummyData(): {
+        getIdToken: () => string;
+        roleArn: string;
+        awsClientSts: {
+            STSClient: {
+                new (): {};
+            };
+            AssumeRoleWithWebIdentityCommand: {
+                new (): {};
+            };
+        };
+        awsClientS3: {
+            S3Client: {
+                new (): {};
+            };
+            PutObjectCommand: {
+                new (): {};
+            };
+            GetObjectCommand: {
+                new (): {};
+            };
+            DeleteObjectCommand: {
+                new (): {};
+            };
+        };
+    };
+    static init(options?: {}): AwsStsS3Client;
+    constructor(options: any);
+    expiration: any;
+    s3Client: any;
+    getIdToken: any;
+    region: any;
+    roleArn: any;
+    roleSessionName: any;
+    durationSession: any;
+    awsClientSts: any;
+    awsClientS3: any;
+    get isExpired(): boolean;
+    get isValid(): boolean;
+    refreshCredentials(): Promise<this>;
+    getS3Client(): Promise<any>;
+    putObject(params: any): Promise<{
+        url: string;
+        filename: any;
+        folder: any;
+        subFolders: any;
+    }>;
+    getObject(params: any): Promise<{
+        body: any;
+        contentType: any;
+        lastModified: any;
+        contentLength: any;
+    }>;
+    deleteObject(params: any): Promise<boolean>;
+}
+
+export declare function calculateAge(timestamp: any, reference: any): number;
+
+export declare function changeCreatorOwner(that: any, { source, target }: {
+    source: any;
+    target: any;
+}): any;
+
+export declare function concatStringByArray(arrTemplate: any, data: any): any;
+
+export declare class ConsoleLog extends QLog {
+    format: any;
+}
+
+export declare function convertString(string: any, patternMatch: RegExp, value: any, getValueByKeys: any): any;
+
+export declare function convertTimestampToString(timestamp: any, dateFormat: any): any;
+
+/**
+ * Unified Middleware Handler (Express & Koa Compatible)
+ */
+declare function customHandler({ responseHelper, handler, ignoreError }: {
+    responseHelper: any;
+    handler: any;
+    ignoreError?: boolean;
+}): (reqOrCtx: any, resOrNext: any, nextInExpress: any) => Promise<any>;
+
+declare const _default: {
+    ApiResponse: typeof models.ApiResponse;
+    makeApiResponse: typeof models.makeApiResponse;
+    AwsStsS3Client: typeof models.AwsStsS3Client;
+    KeyValueObject: typeof models.KeyValueObject;
+    Metadata: typeof models.Metadata;
+    PushEnvelope: typeof models.PushEnvelope;
+    ConsoleLog: typeof models.ConsoleLog;
+    getQLogEnv: typeof models.getQLogEnv;
+    LogRecord: typeof models.LogRecord;
+    QLog: typeof models.QLog;
+    QLogEnv: {
+        debug: {
+            name: string;
+        };
+        production: {
+            name: string;
+        };
+    };
+    QLogLevel: {
+        trace: {
+            weight: number;
+            name: string;
+        };
+        debug: {
+            weight: number;
+            name: string;
+        };
+        info: {
+            weight: number;
+            name: string;
+        };
+        warn: {
+            weight: number;
+            name: string;
+        };
+        error: {
+            weight: number;
+            name: string;
+        };
+        critical: {
+            weight: number;
+            name: string;
+        };
+        alert: {
+            weight: number;
+            name: string;
+        };
+        emergency: {
+            weight: number;
+            name: string;
+        };
+    };
+    QMeta: typeof models.QMeta;
+    Repo: typeof models.Repo;
+    makeService: typeof models.makeService;
+    Service: typeof models.Service;
+    ActionRecord: typeof models.ActionRecord;
+    Status: typeof models.Status;
+    StatusDocument: typeof models.StatusDocument;
+    TemplateCompiler: typeof models.TemplateCompiler;
+    TenantAwareEntity: typeof models.TenantAwareEntity;
+    TrackedEntity: typeof models.TrackedEntity;
+    UniqueKeyGenerator: typeof models.UniqueKeyGenerator;
+    WebAppRequest: typeof models.WebAppRequest;
+    ErrorDetail: typeof models.ErrorDetail;
+    ERROR_CODES: {
+        readonly EXCUTE_EVENT_ERROR: "EXCUTE_EVENT_ERROR";
+        readonly NOT_FOUND: "NOT_FOUND";
+        readonly SERVER_ERROR: "SERVER_ERROR";
+        readonly TIMEOUT: "TIMEOUT";
+        readonly UNAUTHORIZED: "UNAUTHORIZED";
+        readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    };
+    WebAppResponse: typeof models.WebAppResponse;
+    authorize({ allowCoordinator, allowOwner, query, required, user }: {
+        allowCoordinator: any;
+        allowOwner: any;
+        query?: {};
+        required: any;
+        user: any;
+    }): {};
+    calculateAge(timestamp: any, reference: any): number;
+    changeCreatorOwner(that: any, { source, target }: {
+        source: any;
+        target: any;
+    }): any;
+    concatStringByArray: typeof helpers.concatStringByArray;
+    convertString: typeof helpers.convertString;
+    convertTimestampToString(timestamp: any, dateFormat: any): any;
+    detectControlCharacters(input: string, options?: {
+        preserveBasicWhitespace?: boolean;
+    }): any;
+    printControlCharReport(report: any): void;
+    displayName(user: any, options: any): any;
+    downloadFileByUrl: typeof helpers.downloadFileByUrl;
+    escapeRegex(string: any): string;
+    expressHelper: {
+        customHandler: customHandler;
+        findAllResult: findAllResult;
+        findOneResult: findOneResult;
+        hideSensitiveFields: hideSensitiveFields;
+        postResult: postResult;
+        updateOneResult: updateOneResult;
+    };
+    extractEmails(dirtyArray: any[]): any[];
+    formatDate: typeof helpers.formatDate;
+    generalPost: typeof helpers.generalPost;
+    getObjectByArr: typeof helpers.getObjectByArr;
+    getValidation: typeof helpers.getValidation;
+    getValueByKeys: typeof helpers.getValueByKeys;
+    groupArrayByKey(arr: any, key: any): any;
+    init(_class: any, options: any): any;
+    initFromArray(_class: any, arr: any): any[];
+    initOnlyValidFromArray(_class: any, arr: any): any[];
+    isConvertibleToNumber(value: any): boolean;
+    mergeArraysByKey(arr1: any, arr2: any): {
+        key: any;
+        value: any;
+    }[];
+    objectHelper: {
+        expandDotNotation: (obj: any) => {};
+        get: (obj: any, path: any) => any;
+        getNestedValue: (obj: any, path: any) => any;
+        isPlainObject: (value: any) => boolean;
+        merge: (target: any, ...sources: any[]) => any;
+        set: (obj: any, path: any, value: any) => void;
+    };
+    padZeros: typeof helpers.padZeros;
+    pMap(iterable: any, mapper: any, { concurrency, stopOnError, signal, }?: {
+        concurrency?: number;
+        stopOnError?: boolean;
+    }): Promise<any>;
+    pMapIterable(iterable: any, mapper: any, { concurrency, backpressure, }?: {
+        concurrency?: number;
+        backpressure?: any;
+    }): {
+        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    };
+    pMapSkip: typeof helpers.pMapSkip;
+    pReduce: typeof helpers.pReduce;
+    renderByTemplate: typeof helpers.renderByTemplate;
+    replacePlaceholders({ content, mapping }: {
+        content: any;
+        mapping: any;
+    }): any;
+    sanitizeText(input: string, options?: {
+        normalizeWhitespace?: boolean;
+        removeNewlines?: boolean;
+        trim?: boolean;
+        debug?: boolean;
+    }): string;
+    setId(id: any): any;
+    shuffleArray(array: any): any[];
+    stringFormatter: typeof helpers.stringFormatter;
+    stringHelper: {
+        getCssClass: (str: any) => any;
+        isSame: (str1: any, str2: any) => boolean;
+        punctuationless: (str: any) => any;
+        safeToUpperCase: (input: any) => any;
+        setCode: (param: any) => any;
+        toCamelCase: (str: any) => any;
+        toLowerCase: (str: any) => any;
+        toScreamingSnakeCase: (str: any) => any;
+    };
+    tenantPlugin(schema: any, options: any): void;
+    trackingPlugin(schema: any, options: any): void;
+};
+export default _default;
+
+/**
+ * Detects and reports hidden/control characters in a string without modifying it.
+ * @param {string} input - The string to analyze.
+ * @param {Object} [options] - Configuration options.
+ * @param {boolean} [options.preserveBasicWhitespace=true] - Whether to consider basic whitespace as valid.
+ * @returns {Object} Report object with detection results.
+ */
+export declare function detectControlCharacters(input: string, options?: {
+    preserveBasicWhitespace?: boolean;
+}): any;
+
+export declare function displayName(user: any, options: any): any;
+
+export declare function downloadFileByUrl({ dataUrl, filename }?: {
+    dataUrl?: string;
+    filename?: string;
+}): void;
+
+export declare const ERROR_CODES: {
+    readonly EXCUTE_EVENT_ERROR: "EXCUTE_EVENT_ERROR";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};
+
+export declare type ErrorCode = typeof ERROR_CODES[KnownErrorCode];
+
+export declare class ErrorDetail {
+    [key: string]: any;
+    code: ErrorCode | null;
+    message: string;
+    timestamp: number | null;
+    constructor(options?: ErrorDetailOptions);
+    static init(options: any): ErrorDetail | null;
+    get isValid(): boolean;
+}
+
+export declare interface ErrorDetailOptions {
+    code?: ErrorCode;
+    message?: string;
+    timestamp?: number | null;
+}
+
+export declare function escapeRegex(string: any): string;
+
+export declare namespace expressHelper {
+    export { customHandler };
+    export { findAllResult };
+    export { findOneResult };
+    export { hideSensitiveFields };
+    export { postResult };
+    export { updateOneResult };
+}
+
+/**
+ * Extracts and normalizes unique email addresses from an array containing messy entries
+ * @param {Array} dirtyArray - Array that may contain emails in various formats (may include null/empty entries)
+ * @returns {Array} Sorted array of unique, lowercase email addresses
+ */
+export declare function extractEmails(dirtyArray: any[]): any[];
+
+declare function findAllResult({ responseHelper, service }: {
+    responseHelper: any;
+    service: any;
+}): (req: any, res: any, next: any) => Promise<void>;
+
+declare function findOneResult({ responseHelper, service }: {
+    responseHelper: any;
+    service: any;
+}): (req: any, res: any, next: any) => Promise<void>;
+
+export declare function formatDate(date: any, format: any): any;
+
+export declare function generalPost({ body, GeneralModel, UniqueKeyGenerator, resourceInfo }: {
+    body?: {};
+    GeneralModel: any;
+    UniqueKeyGenerator: any;
+    resourceInfo: any;
+}): Promise<any>;
+
+declare function _getDataByKey(key: any, data: any): any;
+
+export declare function getObjectByArr(arr: any, data: any, getValueByKeys: any, getValidation: any, KeyValueObject: any): any;
+
+export declare function getQLogEnv(name: any): any;
+
+export declare function getValidation(rule: any, data: any, getDataByKey?: typeof _getDataByKey, KeyValueObject?: typeof KeyValueObject): any;
+
+export declare function getValueByKeys(keys: any, data: any): any;
+
+export declare function groupArrayByKey(arr: any, key: any): any;
+
+declare namespace helpers {
+    export {
+        authorize,
+        calculateAge,
+        changeCreatorOwner,
+        concatStringByArray,
+        convertString,
+        convertTimestampToString,
+        detectControlCharacters,
+        printControlCharReport,
+        displayName,
+        downloadFileByUrl,
+        escapeRegex,
+        expressHelper,
+        extractEmails,
+        formatDate,
+        generalPost,
+        getObjectByArr,
+        getValidation,
+        getValueByKeys,
+        groupArrayByKey,
+        init,
+        initFromArray,
+        initOnlyValidFromArray,
+        isConvertibleToNumber,
+        mergeArraysByKey,
+        objectHelper,
+        padZeros,
+        pMap,
+        pMapIterable,
+        pMapSkip,
+        pReduce,
+        renderByTemplate,
+        replacePlaceholders,
+        sanitizeText,
+        setId,
+        shuffleArray,
+        stringFormatter,
+        stringHelper,
+        tenantPlugin,
+        trackingPlugin
+    }
+}
+
+declare function hideSensitiveFields(aggregation: any, { query }?: {
+    query?: {};
+}): void;
+
+export declare function init(_class: any, options: any): any;
+
+export declare function initFromArray(_class: any, arr: any): any[];
+
+export declare function initOnlyValidFromArray(_class: any, arr: any): any[];
+
+export declare function isConvertibleToNumber(value: any): boolean;
+
+export declare class KeyValueObject {
+    static init(options?: {}): KeyValueObject;
+    static initFromArray(arr?: any[]): KeyValueObject[];
+    static initOnlyValidFromArray(arr?: any[]): KeyValueObject[];
+    static get _classname(): string;
+    static get _superclass(): string;
+    static addItem(arr: any, key: any, value: any): void;
+    static addRecord(arr: any[], key: any, value: any): any[];
+    static appendRecord(arr: any[], key: any, value: any): any[];
+    static appendValueArray(arr: any[], key: any, value: any): any[];
+    static foundByKey(arr: any[], key: any): any;
+    static foundValueByKey(arr: any[], key: any): any;
+    static fromObject(options?: {}): any[];
+    static getValueByKey(arr: any[], key: any): any;
+    static getMetadataValueByKeyAsArray(arr: any[], key: any): any;
+    static getValueByKeyFromArray(arr: any[], key: any): any;
+    static getValuesByKey(arr: any[], key: any): any;
+    static hasKeyValue(arr: any[], key: any, value: any): boolean;
+    static insertOrUpdateRecord(arr: any[], key: any, value: any): any[];
+    static keys(arr?: any[]): any;
+    static mapToKeyValue(arr?: any[], keyPath?: string, valuePath?: string): any;
+    static merge(toArr: any, fromArr: any): any;
+    static removeByKey(arr: any, key: any): any;
+    static removeByKeys(arr: any, keys: any): any;
+    static sameKey(item: any, key: any): boolean;
+    static toObject(arr?: any[]): any;
+    static toString(arr?: any[], delimiter?: string): any;
+    static updateRecord(arr: any[], key: any, value: any): any[];
+    static updateOrInsertRecord(arr: any[], key: any, value: any): any[];
+    static updateRecordsFromArray(arr?: any[], updateArr?: any[]): any[];
+    static values(arr?: any[]): any;
+    constructor(options?: {});
+    key: any;
+    value: any;
+    get isValid(): boolean;
+    get toObject(): {};
+}
+
+declare type KnownErrorCode = keyof typeof ERROR_CODES;
+
+export declare class LogRecord {
+    constructor(options?: {});
+    data: any;
+    level: any;
+    timestamp: any;
+    stackTrace: any;
+    name: any;
+    zone: any;
+    toString(): string;
+    logName(): string;
+    serialize(): any;
+}
+
+export declare function makeApiResponse({ repo, result }: {
+    repo: any;
+    result: any;
+}): ApiResponse;
+
+export declare function makeService({ repo }: {
+    repo: any;
+}): Service;
+
+export declare function mergeArraysByKey(arr1: any, arr2: any): {
+    key: any;
+    value: any;
+}[];
+
+export declare class Metadata extends KeyValueObject {
+}
+
+declare namespace models {
+    export {
+        ApiResponse,
+        makeApiResponse,
+        AwsStsS3Client,
+        KeyValueObject,
+        Metadata,
+        PushEnvelope,
+        ConsoleLog,
+        getQLogEnv,
+        LogRecord,
+        QLog,
+        QLogEnv,
+        QLogLevel,
+        QMeta,
+        Repo,
+        makeService,
+        Service,
+        ActionRecord,
+        Status,
+        StatusDocument,
+        TemplateCompiler,
+        TenantAwareEntity,
+        TrackedEntity,
+        UniqueKeyGenerator,
+        WebAppRequest,
+        ErrorDetail,
+        ERROR_CODES,
+        WebAppResponse,
+        ErrorDetailOptions,
+        ErrorCode
+    }
+}
+
+export declare namespace objectHelper {
+    export { expandDotNotation };
+    export { get };
+    export { getNestedValue };
+    export { isPlainObject };
+    export { merge };
+    export { set };
+}
+
+export declare function padZeros(num: any, minLength?: number): any;
+
+export declare function pMap(iterable: any, mapper: any, { concurrency, stopOnError, signal, }?: {
+    concurrency?: number;
+    stopOnError?: boolean;
+}): Promise<any>;
+
+export declare function pMapIterable(iterable: any, mapper: any, { concurrency, backpressure, }?: {
+    concurrency?: number;
+    backpressure?: any;
+}): {
+    [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+};
+
+export declare const pMapSkip: unique symbol;
+
+declare function postResult({ responseHelper, service }: {
+    responseHelper: any;
+    service: any;
+}): (req: any, res: any, next: any) => Promise<void>;
+
+export declare function pReduce(iterable: any, reducer: any, initialValue: any): Promise<any>;
+
+/**
+ * Pretty print the detection results to console
+ */
+export declare function printControlCharReport(report: any): void;
+
+export declare class PushEnvelope extends TrackedEntity {
+    constructor(options: any);
+    body: any;
+    data: any;
+    dirty: any;
+    metadata: KeyValueObject[];
+    remarks: KeyValueObject[];
+    threadID: any;
+    title: any;
+    get _classname(): string;
+    get _superclass(): string;
+    get isValid(): any;
+}
+
+export declare class QLog {
+    static getInstance(options: any): any;
+    constructor(options?: {});
+    _level: any;
+    _handlers: Map<any, any>;
+    setLevel(level: any): this;
+    addHandler(handler: any): this;
+    removeHandler(handlerClass: any): this;
+    receive({ record }: {
+        record: any;
+    }): void;
+    logBody(record: any): void;
+    trace(options: any, object: any): void;
+    debug(options: any, object: any): void;
+    info(options: any, object: any): void;
+    warn(options: any, object: any): void;
+    error(options: any, object: any): void;
+    critical(options: any, object: any): void;
+    _log({ level, object, options }: {
+        level: any;
+        object: any;
+        options: any;
+    }): void;
+}
+
+export declare namespace QLogEnv {
+    export namespace debug {
+        let name: string;
+    }
+    export namespace production {
+        let name_1: string;
+        export { name_1 as name };
+    }
+}
+
+export declare namespace QLogLevel {
+    export namespace trace {
+        let weight: number;
+        let name: string;
+    }
+    export namespace debug {
+        let weight_1: number;
+        export { weight_1 as weight };
+        let name_1: string;
+        export { name_1 as name };
+    }
+    export namespace info {
+        let weight_2: number;
+        export { weight_2 as weight };
+        let name_2: string;
+        export { name_2 as name };
+    }
+    export namespace warn {
+        let weight_3: number;
+        export { weight_3 as weight };
+        let name_3: string;
+        export { name_3 as name };
+    }
+    export namespace error {
+        let weight_4: number;
+        export { weight_4 as weight };
+        let name_4: string;
+        export { name_4 as name };
+    }
+    export namespace critical {
+        let weight_5: number;
+        export { weight_5 as weight };
+        let name_5: string;
+        export { name_5 as name };
+    }
+    export namespace alert {
+        let weight_6: number;
+        export { weight_6 as weight };
+        let name_6: string;
+        export { name_6 as name };
+    }
+    export namespace emergency {
+        let weight_7: number;
+        export { weight_7 as weight };
+        let name_7: string;
+        export { name_7 as name };
+    }
+}
+
+export declare class QMeta {
+    static get _classname(): string;
+    static get _superclass(): string;
+    static init(options?: {}): QMeta;
+    constructor(options?: {});
+    attributes: KeyValueObject[];
+    ref: any;
+    addAttribute(obj: any): this;
+    update(obj: any): this;
+}
+
+export declare function renderByTemplate({ engine, template, value }?: {}): any;
+
+export declare function replacePlaceholders({ content, mapping }: {
+    content: any;
+    mapping: any;
+}): any;
+
+export declare class Repo {
+    static init(options?: {}): any;
+    static get _classname(): string;
+    static get _superclass(): string;
+    constructor(options: any);
+    model: any;
+    _sharedOptions: any;
+    _queryOptions: any;
+    _saveOptions: any;
+    _Class: any;
+    get _classname(): string;
+    get _superclass(): string;
+    get isValid(): boolean;
+    get queryOptions(): any;
+    get saveOptions(): any;
+    init(options: any): any;
+    deleteOne({ id }: {
+        id: any;
+    }): Promise<any>;
+    findAll({ config, query, systemLog }: {
+        config?: {};
+        query: any;
+        systemLog: any;
+    }): Promise<any>;
+    findOne({ config, query, systemLog }: {
+        config?: {};
+        query: any;
+        systemLog: any;
+    }): Promise<any>;
+    saveAll({ config, docs, systemLog }: {
+        config?: {};
+        docs: any;
+        systemLog: any;
+    }): any;
+    saveOne({ config, doc, systemLog }: {
+        config?: {};
+        doc: any;
+        systemLog: any;
+    }): Promise<any>;
+}
+
+/**
+ * Sanitizes input by removing hidden/control characters with customizable whitespace handling.
+ * @param {string} input - The string to sanitize.
+ * @param {object} [options] - Configuration options.
+ * @param {boolean} [options.normalizeWhitespace] - Collapse multiple spaces/tabs into one space.
+ * @param {boolean} [options.removeNewlines] - If true, replaces newlines with spaces.
+ * @param {boolean} [options.trim] - If true, trims leading/trailing whitespace.
+ * @param {boolean} [options.debug] - If true, logs debug information about removed characters.
+ * @returns {string} The sanitized string.
+ */
+export declare function sanitizeText(input: string, options?: {
+    normalizeWhitespace?: boolean;
+    removeNewlines?: boolean;
+    trim?: boolean;
+    debug?: boolean;
+}): string;
+
+export declare class Service {
+    static get _classname(): string;
+    static get _superclass(): string;
+    constructor({ repo }: {
+        repo: any;
+    });
+    repo: any;
+    deleteOne({ id }: {
+        id: any;
+    }): Promise<ApiResponse>;
+    findAll({ config, query, systemLog }?: {
+        config?: {};
+        query?: {};
+    }): Promise<ApiResponse>;
+    findOne({ config, query, systemLog }?: {
+        config?: {};
+        query?: {};
+    }): Promise<ApiResponse>;
+    init(options: any): any;
+    initFromArray(arr?: any[]): any[];
+    initOnlyValidFromArray(arr?: any[]): any[];
+    saveAll({ config, docs, systemLog }?: {
+        config?: {};
+        docs?: any[];
+    }): Promise<ApiResponse>;
+    saveOne({ config, doc, systemLog }?: {
+        config?: {};
+        doc?: {};
+    }): Promise<ApiResponse | {
+        isNew: any;
+        data: any[];
+        err: Error;
+    }>;
+}
+
+export declare function setId(id: any): any;
+
+export declare function shuffleArray(array: any): any[];
+
+export declare class Status {
+    static get _classname(): string;
+    static get _superclass(): string;
+    static dummyData(): {};
+    static init(options?: {}): any;
+    static initFromArray(arr?: any[]): any[];
+    static initOnlyValidFromArray(arr?: any[]): any[];
+    constructor(options: any);
+    _ActionRecord: any;
+    created: any;
+    get _classname(): string;
+    get _superclass(): string;
+    get isCreated(): boolean;
+    get isValid(): boolean;
+    setValue(t: any, actorCode: any, key: any): this;
+    update(update: any): this;
+}
+
+export declare class StatusDocument extends Status {
+    archived: any;
+    completed: any;
+    discarded: any;
+    drafted: any;
+    get isArchived(): boolean;
+    get isCompleted(): boolean;
+    get isDiscarded(): boolean;
+    get isDrafted(): boolean;
+    setArchived(value: any, actorCode: any): this;
+    setCompleted(value: any, actorCode: any): this;
+    setDiscarded(value: any, actorCode: any): this;
+    setDrafted(value: any, actorCode: any): this;
+}
+
+export declare function stringFormatter(str: any, delimiter?: string): any;
+
+export declare namespace stringHelper {
+    export { getCssClass };
+    export { isSame };
+    export { punctuationless };
+    export { safeToUpperCase };
+    export { setCode };
+    export { toCamelCase };
+    export { toLowerCase };
+    export { toScreamingSnakeCase };
+}
+
+export declare class TemplateCompiler {
+    static init(options: any): TemplateCompiler;
+    static initFromArray(arr?: any[]): TemplateCompiler[];
+    static initOnlyValidFromArray(arr?: any[]): TemplateCompiler[];
+    static concatIf(data: any, args: any): any;
+    static divide(data: any, args: any): any;
+    static eq(data: any, args: any): any;
+    static filterAll(data: any, args: any): any;
+    static formatDate(data: any, args: any): any;
+    static get(data: any, key: any, failover?: any): any;
+    static gt(data: any, args: any): any;
+    static gte(data: any, args: any): any;
+    static isEmpty(data: any, args: any): any;
+    static isNotEmpty(data: any, args: any): any;
+    static join(data: any, separator?: string): any;
+    static lt(data: any, args: any): any;
+    static lte(data: any, args: any): any;
+    static map(data: any, args?: any[]): any;
+    static neq(data: any, args: any): any;
+    static removeHtml(data: any, args: any): any;
+    static replaceChar(data: any, args: any): any;
+    static sum(data: any, args: any): any;
+    static toLowerCase(data: any, args: any): string;
+    static toUpperCase(data: any, args: any): string;
+    static parseFunction(expression: any): any;
+    static parseParams(parameters: any): any[];
+    constructor(data: any);
+    data: any;
+    pipe(expression?: string): any;
+    delimiters: string[];
+}
+
+export declare class TenantAwareEntity extends TrackedEntity {
+    static dummyData(): {
+        metadata: any[];
+        remarks: any[];
+        tenantCode: string;
+        meta: {
+            active: boolean;
+            deleted: boolean;
+            created: number;
+            creator: string;
+            modified: number;
+            owner: string;
+        };
+    };
+    _tenant: any;
+    metadata: KeyValueObject[];
+    remarks: KeyValueObject[];
+    tenantCode: any;
+    get __valid(): {
+        tenantCode: any;
+    };
+    insertOrUpdateMetadata(key: any, value: any): this;
+    getMetadata(): KeyValueObject[];
+    getMetadataByKey(key: any): any;
+    getMetadataValueByKey(key: any): any;
+    getMetadataValueByKeys(keys: any, kv: any): any;
+    getMetadataValueByKeyAsArray(key: any): any;
+    getRemarks(): KeyValueObject[];
+    getRemarkByKey(key: any): any;
+    getRemarksValueByKey(key: any): any;
+    getTenantCode(): any;
+    update(update: any): this;
+}
+
+export declare function tenantPlugin(schema: any, options: any): void;
+
+export declare class TrackedEntity {
+    static dummyData(): {
+        meta: {
+            active: boolean;
+            deleted: boolean;
+            created: number;
+            creator: string;
+            modified: number;
+            owner: string;
+        };
+    };
+    static get _classname(): string;
+    static get _superclass(): string;
+    static init(options?: {}): any;
+    static initFromArray(arr?: any[]): any[];
+    static initOnlyValidFromArray(arr?: any[]): any[];
+    static ALLOWED_META_PROPS: string[];
+    constructor(options?: {});
+    id: any;
+    _type: any;
+    meta: {
+        active: any;
+        created: any;
+        creator: any;
+        deleted: any;
+        modified: any;
+        owner: any;
+    };
+    get __valid(): {};
+    get isValid(): boolean;
+    get active(): any;
+    get created(): any;
+    get creator(): any;
+    get deleted(): any;
+    get modified(): any;
+    get owner(): any;
+    changeCreatorOwner({ source, target }: {
+        source: any;
+        target: any;
+    }): any;
+    delete(): this;
+    setActive(): this;
+    setDeleted(): this;
+    setModified(): this;
+    setOwner(owner: any): this;
+    unsetActive(): this;
+    unsetDeleted(): this;
+    update(update: any): this;
+}
+
+export declare function trackingPlugin(schema: any, options: any): void;
+
+export declare class UniqueKeyGenerator {
+    static get _classname(): string;
+    static get _superclass(): string;
+    static makeFormatter({ fieldName, format, options }: {
+        fieldName: any;
+        format: any;
+        options: any;
+    }): (obj?: {}) => Promise<{
+        [x: number]: any;
+    }>;
+    static makeGenerator(arr: any): (obj: any) => Promise<any>;
+}
+
+declare function updateOneResult({ responseHelper, service }: {
+    responseHelper: any;
+    service: any;
+}): (req: any, res: any, next: any) => Promise<void>;
+
+export declare class WebAppRequest {
+    [key: string]: any;
+    blockUI: boolean | null;
+    callback: WebAppResponseCallbackFunction | null;
+    data: any[] | null;
+    event: string | null;
+    reloadPage: boolean | null;
+    sessionId: string | null;
+    timeout: number | null;
+    constructor(options?: WebAppRequestOptions);
+    static get _classname(): string;
+    static get _superclass(): string;
+    static init(options: any): WebAppRequest | null;
+    static dummyData(): WebAppRequestOptions;
+    get isValid(): boolean;
+    getId(): string | null;
+}
+
+declare interface WebAppRequestOptions {
+    blockUI?: boolean | null;
+    callback?: WebAppResponseCallbackFunction | null;
+    data?: any[] | null;
+    event?: string | null;
+    reloadPage?: boolean | null;
+    sessionId?: string | null;
+    timeout?: number | null;
+}
+
+export declare class WebAppResponse {
+    [key: string]: any;
+    data: any[] | null;
+    errorDetail: ErrorDetail | null;
+    sessionId: string | null;
+    success: boolean;
+    constructor(options?: WebAppResponseOptions);
+    static get _classname(): string;
+    static get _superclass(): string;
+    static init(options: any): WebAppResponse | null;
+    static dummyData(): WebAppResponseOptions;
+    get isValid(): boolean;
+    getId(): string | null;
+}
+
+declare type WebAppResponseCallbackFunction = (WebAppResponse: any) => void;
+
+declare interface WebAppResponseOptions {
+    data?: any[] | null;
+    errorDetail?: any | null;
+    sessionId?: string | null;
+    success?: boolean;
+}
+
+export { }