@leyyo/common 1.0.0 → 1.0.2

package/dist/error/index-types.d.ts

@@ -1,8 +1,7 @@
-import { Leyyo } from "../leyyo";
-import { Abstract, ClassLike, Dict, ShiftMain, ShiftSecure } from "../aliases";
-import { Exception } from "./exception";
-import { CommonCallbackDefined } from "../callback";
+import { Dict, InitLike, ShiftMain, ShiftSecure } from "../shared";
+import { ExceptionLike } from "../exception";
 export interface CommonError extends ShiftSecure<CommonErrorSecure> {
+    register(cls: Function): void;
     build(e: Error | string): ExceptionLike;
     afterCreate(e: ExceptionLike): void;
     causedBy(e: Error | string): ExceptionLike;
@@ -13,58 +12,10 @@ export interface CommonError extends ShiftSecure<CommonErrorSecure> {
     hasSign(err: Error, key: string): boolean;
     toObject(e: Error, ...omittedFields: Array<string>): Dict;
     buildStack(e: Error): void;
-    copyStack(exception: Exception, error: Error): void;
+    copyStack(exception: ExceptionLike, error: Error): void;
     initOmit(clz: Function): boolean;
     addOmit(clz: Function, ...properties: Array<string>): boolean;
     getOmit(clz: Function): Array<string>;
     inheritOmit(clz: Function): Array<string>;
 }
-export interface CommonErrorCb extends CommonCallbackDefined {
-    build?(e: Error | string): ExceptionLike;
-    afterCreate?(e: ExceptionLike): void;
-    causedBy?(e: Error | string): ExceptionLike;
-    initSign?(err: Error): boolean;
-    addSign?(err: Error, ...keys: Array<string>): boolean;
-    getSign?(err: Error): Array<string>;
-    removeSign?(err: Error, ...keys: Array<string>): boolean;
-    hasSign?(err: Error, key: string): boolean;
-    toObject?(e: Error, ...omittedFields: Array<string>): Dict;
-    buildStack?(e: Error): void;
-    copyStack?(exception: Exception, error: Error): void;
-    initOmit?(clz: Function): boolean;
-    addOmit?(clz: Function, ...properties: Array<string>): boolean;
-    getOmit?(clz: Function): Array<string>;
-    inheritOmit?(clz: Function): Array<string>;
-}
-export interface CommonErrorSecure extends ShiftMain<CommonError> {
-    $init(leyyo: Leyyo): void;
-}
-export interface ExceptionStackLine {
-    file?: string;
-    method?: string;
-    line?: number;
-    column?: number;
-}
-export interface ExceptionParamsAppend extends Dict {
-    indicator?: string;
-}
-export interface ExceptionLike extends Error, ShiftSecure<ExceptionSecure> {
-    get params(): Dict;
-    causedBy(e: Error | string): this;
-    with(clazz: ClassLike): this;
-    with(instance: Abstract<any>): this;
-    with(name: string): this;
-    with(value: any): this;
-    appendParams(params: ExceptionParamsAppend, ignoreExisting?: boolean): this;
-    log(req?: unknown): this;
-    raise(throwable?: boolean, req?: unknown): this;
-    toObject(...omittedFields: Array<string>): Dict;
-    toJSON(): Dict;
-}
-export interface ExceptionSecure extends ShiftMain<ExceptionLike> {
-    $setName(name: string): this;
-    $hasSign(key: string): boolean;
-    $listSigns(): Array<string>;
-    $addSign(...keys: Array<string>): boolean;
-    $removeSign(...keys: Array<string>): boolean;
-}
+export type CommonErrorSecure = ShiftMain<CommonError> & InitLike;

package/dist/error/index.d.ts

@@ -1,7 +1,2 @@
 export * from './index-types';
 export * from './common-error-impl';
-export * from './exception';
-export * from './caused-exception';
-export * from './developer-exception';
-export * from './assertion-exception';
-export * from './multiple-exception';

package/dist/error/index.js

@@ -16,8 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-types"), exports);
 __exportStar(require("./common-error-impl"), exports);
-__exportStar(require("./exception"), exports);
-__exportStar(require("./caused-exception"), exports);
-__exportStar(require("./developer-exception"), exports);
-__exportStar(require("./assertion-exception"), exports);
-__exportStar(require("./multiple-exception"), exports);

package/dist/{error → exception}/assertion-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { AssertionOpt } from "../assertion";
+import { AssertionOpt } from "../shared";
 export declare class AssertionException extends Exception {
     constructor(indicator?: string, params?: AssertionOpt);
 }

package/dist/{error → exception}/caused-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { Dict } from "../aliases";
+import { Dict } from "../shared";
 export declare class CausedException extends Exception {
     constructor(e: Error, indicator?: string, params?: Dict);
 }

package/dist/{error → exception}/developer-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { AssertionOpt } from "../assertion";
+import { AssertionOpt } from "../shared";
 export declare class DeveloperException extends Exception {
     constructor(indicator?: string, params?: AssertionOpt);
 }

package/dist/{error → exception}/exception.d.ts

@@ -1,8 +1,9 @@
-import { CommonError, ExceptionLike, ExceptionParamsAppend, ExceptionSecure, ExceptionStackLine } from "./index-types";
-import { Abstract, ClassLike, ClassOrName, Dict } from "../aliases";
+import { CommonError } from "../error";
+import { Abstract, ClassLike, ClassOrName, Dict } from "../shared";
 import { Leyyo } from "../leyyo";
+import { ExceptionLike, ExceptionParamsAppend, ExceptionSecure, ExceptionStackLine } from "./index-types";
 export declare class Exception extends Error implements ExceptionLike, ExceptionSecure {
-    private static _callback;
+    private static _fqn;
     private static _error;
     private static _log;
     private static _assertion;

package/dist/{error → exception}/exception.js

@@ -7,7 +7,7 @@ class Exception extends Error {
             message += ` => ${JSON.stringify(Exception._assertion.secureJson(params))}`;
         }
         super(message);
-        this.name = Exception._callback.fqnName(this);
+        this.name = Exception._fqn.name(this);
         this._params = params !== null && params !== void 0 ? params : {};
         this._parsed = [];
         Exception._error.afterCreate(this);
@@ -27,7 +27,7 @@ class Exception extends Error {
         return this;
     }
     with(value) {
-        this._holder = Exception._callback.fqnName(value);
+        this._holder = Exception._fqn.name(value);
         return this;
     }
     appendParams(params, ignoreExisting) {
@@ -98,8 +98,8 @@ class Exception extends Error {
         return Exception._error.removeSign(this, ...keys);
     }
     static $setLeyyo(leyyo) {
-        if (!this._callback) {
-            this._callback = leyyo.callback;
+        if (!this._fqn) {
+            this._fqn = leyyo.fqn;
         }
         if (!this._error) {
             this._error = leyyo.error;

package/dist/exception/index-types.d.ts

@@ -0,0 +1,30 @@
+import { Abstract, ClassLike, Dict, ShiftMain, ShiftSecure } from "../shared";
+export interface ExceptionStackLine {
+    file?: string;
+    method?: string;
+    line?: number;
+    column?: number;
+}
+export interface ExceptionParamsAppend extends Dict {
+    indicator?: string;
+}
+export interface ExceptionLike extends Error, ShiftSecure<ExceptionSecure> {
+    get params(): Dict;
+    causedBy(e: Error | string): this;
+    with(clazz: ClassLike): this;
+    with(instance: Abstract<any>): this;
+    with(name: string): this;
+    with(value: any): this;
+    appendParams(params: ExceptionParamsAppend, ignoreExisting?: boolean): this;
+    log(req?: unknown): this;
+    raise(throwable?: boolean, req?: unknown): this;
+    toObject(...omittedFields: Array<string>): Dict;
+    toJSON(): Dict;
+}
+export interface ExceptionSecure extends ShiftMain<ExceptionLike> {
+    $setName(name: string): this;
+    $hasSign(key: string): boolean;
+    $listSigns(): Array<string>;
+    $addSign(...keys: Array<string>): boolean;
+    $removeSign(...keys: Array<string>): boolean;
+}

package/dist/exception/index.d.ts

@@ -0,0 +1,6 @@
+export * from './index-types';
+export * from './exception';
+export * from './caused-exception';
+export * from './developer-exception';
+export * from './assertion-exception';
+export * from './multiple-exception';

package/dist/exception/index.js

@@ -0,0 +1,22 @@
+"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("./index-types"), exports);
+__exportStar(require("./exception"), exports);
+__exportStar(require("./caused-exception"), exports);
+__exportStar(require("./developer-exception"), exports);
+__exportStar(require("./assertion-exception"), exports);
+__exportStar(require("./multiple-exception"), exports);

package/dist/fqn/common-fqn-impl.d.ts

@@ -0,0 +1,11 @@
+import { CommonFqn, CommonFqnSecure } from "./index-types";
+import { Leyyo } from "../leyyo";
+import { FqnStereoType } from "../shared";
+export declare class CommonFqnImpl implements CommonFqn, CommonFqnSecure {
+    private hook;
+    get $back(): CommonFqn;
+    $init(leyyo: Leyyo): void;
+    get $secure(): CommonFqnSecure;
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}

package/dist/fqn/common-fqn-impl.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonFqnImpl = void 0;
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols
+class CommonFqnImpl {
+    get $back() {
+        return this;
+    }
+    $init(leyyo) {
+        this.hook = leyyo.hook;
+        const fields = ['name', 'register'];
+        const rec = { proper: false };
+        fields.forEach(field => {
+            rec[field] = this[field];
+        });
+        // define itself temporarily for fqn operations
+        leyyo.hook.defineProvider(shared_1.LY_ATTACHED_FQN, CommonFqnImpl, rec);
+        // when new fqn provider is defined, replace all common methods
+        leyyo.hook.whenProviderDefined(shared_1.LY_ATTACHED_FQN, CommonFqnImpl, (ins) => {
+            fields.forEach(field => {
+                if (typeof ins[field] === 'function') {
+                    this[field] = ins[field];
+                }
+            });
+        });
+    }
+    get $secure() {
+        return this;
+    }
+    name(value) {
+        switch (typeof value) {
+            case "function":
+                return value.name;
+            case "object":
+                return value.constructor.name;
+            case "string":
+                return value;
+            default:
+                return null;
+        }
+    }
+    register(value, type, pckName) {
+        this.hook.queueForCallback(shared_1.LY_PENDING_FQN_REGISTER, value, type, pckName);
+    }
+}
+exports.CommonFqnImpl = CommonFqnImpl;

package/dist/fqn/index-types.d.ts

@@ -0,0 +1,6 @@
+import { FqnStereoType, InitLike, ShiftMain, ShiftSecure } from "../shared";
+export interface CommonFqn extends ShiftSecure<CommonFqnSecure> {
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}
+export type CommonFqnSecure = ShiftMain<CommonFqn> & InitLike;

package/dist/fqn/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/fqn/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './common-fqn-impl';

package/dist/{callback → fqn}/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-types"), exports);
-__exportStar(require("./common-callback-impl"), exports);
+__exportStar(require("./common-fqn-impl"), exports);

package/dist/hook/common-hook-impl.d.ts

@@ -0,0 +1,30 @@
+import { Arr, HookDefinedProvider, HookDefinedProviderLambda } from "../shared";
+import { Leyyo } from "../leyyo";
+import { CommonHook, CommonHookSecure } from "./index-types";
+export declare class CommonHookImpl implements CommonHook, CommonHookSecure {
+    private _waitingForCallbacks;
+    private _attachedCallbacks;
+    private _waitingForProviders;
+    private _definedProviders;
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor();
+    $init(leyyo: Leyyo): void;
+    /**
+     * Clear jobs in the queue which channel as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    private _clearPending;
+    get $secure(): CommonHookSecure;
+    attachCallback(channel: string, fn: Function): void;
+    queueForCallback(channel: string, ...args: Arr): boolean;
+    get $back(): CommonHook;
+    whenProviderDefined<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, consumer: Function, callback: HookDefinedProviderLambda<T>): void;
+    defineProvider<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, producer: Function, instance: T): void;
+}

package/dist/hook/common-hook-impl.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHookImpl = void 0;
+const internal_1 = require("../internal");
+const exception_1 = require("../exception");
+// noinspection JSUnusedGlobalSymbols
+class CommonHookImpl {
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor() {
+        // clear after 1 minute
+        setTimeout(() => this._clearPending(), 60000);
+    }
+    $init(leyyo) {
+        this._waitingForCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForCallbacks`);
+        this._attachedCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/attachedCallbacks`);
+        this._waitingForProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForProviders`);
+        this._definedProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/definedProviders`);
+    }
+    /**
+     * Clear jobs in the queue which channel as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    _clearPending() {
+        for (const [channel,] of this._waitingForCallbacks.entries()) {
+            const rec = this._attachedCallbacks.get(channel);
+            if (rec && !rec.initialization) {
+                continue;
+            }
+            this._waitingForCallbacks.delete(channel);
+            console.log(`hook.cleared.pending => {channel: ${channel}}`);
+        }
+    }
+    get $secure() {
+        return this;
+    }
+    attachCallback(channel, fn) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback attached
+        this._attachedCallbacks.set(channel, { fn });
+        // check waiting records, to be called
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).forEach(item => {
+                fn(...item);
+            });
+            this._waitingForCallbacks.delete(channel);
+        }
+    }
+    queueForCallback(channel, ...args) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback already exists
+        if (this._attachedCallbacks.has(channel)) {
+            const rec = this._attachedCallbacks.get(channel);
+            rec.fn(...args);
+            return true;
+        }
+        // callback does not exist yet, so wait to be attached
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).push(args);
+        }
+        else {
+            this._waitingForCallbacks.set(channel, [args]);
+        }
+        return false;
+    }
+    get $back() {
+        return undefined;
+    }
+    whenProviderDefined(channel, consumer, callback) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        if (!this._waitingForProviders.has(channel)) {
+            this._waitingForProviders.set(channel, []);
+        }
+        if (this._definedProviders.has(channel)) {
+            const ins = this._definedProviders.get(channel);
+            if (ins.producer !== consumer) {
+                callback(ins);
+            }
+        }
+        this._waitingForProviders.get(channel).push({ consumer, callback });
+    }
+    defineProvider(channel, producer, instance) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        const ins = Object.assign(Object.assign({}, instance), { producer });
+        this._definedProviders.set(channel, ins);
+        if (instance.proper) {
+            if (this._waitingForProviders.has(channel)) {
+                this._waitingForProviders.get(channel).forEach(item => {
+                    if (item.consumer !== producer) {
+                        item.callback(instance);
+                    }
+                });
+            }
+        }
+    }
+}
+exports.CommonHookImpl = CommonHookImpl;

package/dist/hook/index-types.d.ts

@@ -0,0 +1,56 @@
+import { Arr, HookDefinedProvider, HookDefinedProviderLambda, InitLike, ShiftMain, ShiftSecure } from "../shared";
+/**
+ * Hook interface, it collects all jobs and fire them when callback is defined
+ * */
+export interface CommonHook extends ShiftSecure<CommonHookSecure> {
+    /**
+     * Attach a callback
+     *
+     * @param {string} channel
+     * @param {Function} fn
+     *
+     * Notes:
+     * - channel should be regular string
+     * - After attached, it should call all waiting calls in the queue
+     * */
+    attachCallback(channel: string, fn: Function): void;
+    /**
+     * Add a call into queue, which to be executed by appropriate callback
+     *
+     * @param {string} channel
+     * @param {Array<any>} args
+     * @returns {boolean} - channel exists?
+     *
+     * Notes:
+     * - channel should be regular string
+     * */
+    queueForCallback(channel: string, ...args: Arr): boolean;
+    /**
+     * Informs when callback is changed
+     *
+     * @param {string} channel
+     * @param {Function} consumer
+     * @param {HookDefinedProviderLambda} callback
+     *
+     * Notes:
+     * - channel should be regular string
+     * - callback should be regular function
+     * - channel should not be already defined
+     * */
+    whenProviderDefined<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, consumer: Function, callback: HookDefinedProviderLambda<T>): void;
+    /**
+     * Defines a provider to replace temporary providers
+     *
+     * @param {string} channel
+     * @param {Function} producer
+     * @param {Object} instance
+     *
+     * Notes:
+     * - channel should be regular string
+     * */
+    defineProvider<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, producer: Function, instance: T): void;
+}
+/**
+ * Secure hook interface
+ * */
+export type CommonHookSecure = ShiftMain<CommonHook> & InitLike;

package/dist/hook/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hook/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './common-hook-impl';

package/dist/hook/index.js

@@ -0,0 +1,18 @@
+"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("./index-types"), exports);
+__exportStar(require("./common-hook-impl"), exports);

package/dist/index.d.ts

@@ -1,7 +1,13 @@
+export * from './exception';
+export * from './literal';
+export * from './shared';
 import { leyyo } from "./leyyo";
-export * from './aliases';
-export * from './constants';
-export * from './literals';
 declare const is: import("./is").CommonIs;
-declare const callback: import("./callback").CommonCallback;
-export { leyyo, is, callback };
+declare const hook: import("./hook").CommonHook;
+declare const assertion: import("./assertion").CommonAssertion;
+declare const storage: import("./storage").CommonStorage;
+declare const to: import("./to").CommonTo;
+declare const commonFqn: import("./fqn").CommonFqn;
+declare const commonLog: import("./log").CommonLog;
+declare const commonError: import("./error").CommonError;
+export { leyyo, is, hook, assertion, storage, to, commonFqn, commonLog, commonError };

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+// noinspection JSUnusedGlobalSymbols
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,13 +15,25 @@ 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 });
-exports.callback = exports.is = exports.leyyo = void 0;
+exports.commonError = exports.commonLog = exports.commonFqn = exports.to = exports.storage = exports.assertion = exports.hook = exports.is = exports.leyyo = void 0;
+__exportStar(require("./exception"), exports);
+__exportStar(require("./literal"), exports);
+__exportStar(require("./shared"), exports);
 const leyyo_1 = require("./leyyo");
 Object.defineProperty(exports, "leyyo", { enumerable: true, get: function () { return leyyo_1.leyyo; } });
-__exportStar(require("./aliases"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./literals"), exports);
 const is = leyyo_1.leyyo.is;
 exports.is = is;
-const callback = leyyo_1.leyyo.callback;
-exports.callback = callback;
+const hook = leyyo_1.leyyo.hook;
+exports.hook = hook;
+const assertion = leyyo_1.leyyo.assertion;
+exports.assertion = assertion;
+const storage = leyyo_1.leyyo.storage;
+exports.storage = storage;
+const to = leyyo_1.leyyo.to;
+exports.to = to;
+const commonFqn = leyyo_1.leyyo.fqn;
+exports.commonFqn = commonFqn;
+const commonLog = leyyo_1.leyyo.log;
+exports.commonLog = commonLog;
+const commonError = leyyo_1.leyyo.error;
+exports.commonError = commonError;

package/dist/is/common-is-impl.d.ts

@@ -1,22 +1,43 @@
 import { CommonIs, CommonIsSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
+/** @inheritDoc */
 export declare class CommonIsImpl implements CommonIs, CommonIsSecure {
+    /** @inheritDoc */
+    empty(value: any): boolean;
+    /** @inheritDoc */
+    primitive(value: any): boolean;
+    /** @inheritDoc */
+    realValue(value: any): boolean;
+    /** @inheritDoc */
+    key(value: any): boolean;
+    /** @inheritDoc */
+    object(value: any): boolean;
+    /** @inheritDoc */
+    array(value: any): boolean;
+    /** @inheritDoc */
+    func(value: any): boolean;
+    /** @inheritDoc */
+    number(value: any): boolean;
+    /** @inheritDoc */
+    integer(value: any): boolean;
+    /** @inheritDoc */
+    safeInteger(value: any): boolean;
+    /** @inheritDoc */
+    string(value: any): boolean;
+    /** @inheritDoc */
+    text(value: any): boolean;
+    /** @inheritDoc */
+    clazz(value: any): boolean;
+    /** @inheritDoc */
+    boolean(value: any): boolean;
+    /** @inheritDoc */
+    true(value: any): boolean;
+    /** @inheritDoc */
+    false(value: any): boolean;
+    /** @inheritDoc */
     $init(leyyo: Leyyo): void;
-    empty(value: unknown): boolean;
-    primitive(value: unknown): boolean;
-    value(value: unknown): boolean;
-    key(value: unknown): boolean;
-    object(value: unknown): boolean;
-    array(value: unknown): boolean;
-    func(value: unknown): boolean;
-    number(value: unknown): boolean;
-    integer(value: unknown): boolean;
-    string(value: unknown): boolean;
-    text(value: unknown): boolean;
-    clazz(value: unknown): boolean;
-    boolean(value: unknown): boolean;
-    true(value: unknown): boolean;
-    false(value: unknown): boolean;
+    /** @inheritDoc */
     get $back(): CommonIs;
+    /** @inheritDoc */
     get $secure(): CommonIsSecure;
 }