@leyyo/common 1.0.1 → 1.0.2

package/dist/literal/real-value.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealValueItems = void 0;
+/**
+ * Real Value items
+ * */
+exports.RealValueItems = ['string', 'number', 'bigint', 'boolean', 'object', 'function'];

package/dist/literal/severity.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Severity items
+ * */
+export declare const SeverityItems: readonly ["debug", "error", "fatal", "info", "log", "trace", "warn"];
+/**
+ * Severity for log and errors
+ * */
+export type Severity = typeof SeverityItems[number];

package/dist/literal/severity.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeverityItems = void 0;
+/**
+ * Severity items
+ * */
+exports.SeverityItems = ['debug', 'error', 'fatal', 'info', 'log', 'trace', 'warn'];

package/dist/literal/storage-type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak True items
+ * */
+export declare const StorageTypeItems: readonly ["array", "list", "map", "set"];
+/**
+ * Storage type literal, as an enum
+ * */
+export type StorageType = typeof StorageTypeItems[number];

package/dist/literal/storage-type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageTypeItems = void 0;
+/**
+ * Weak True items
+ * */
+exports.StorageTypeItems = ['array', 'list', 'map', 'set'];

package/dist/literal/weak-false.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak False items
+ * */
+export declare const WeakFalseItems: readonly ["0", "-1", "false", "f", "no", "n", "off"];
+/**
+ * Weak False
+ * */
+export type WeakFalse = typeof WeakFalseItems[number];

package/dist/literal/weak-false.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeakFalseItems = void 0;
+/**
+ * Weak False items
+ * */
+exports.WeakFalseItems = ['0', '-1', 'false', 'f', 'no', 'n', 'off'];

package/dist/literal/weak-true.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak True items
+ * */
+export declare const WeakTrueItems: readonly ["1", "true", "t", "yes", "y", "on"];
+/**
+ * Weak True
+ * */
+export type WeakTrue = typeof WeakTrueItems[number];

package/dist/literal/weak-true.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeakTrueItems = void 0;
+/**
+ * Weak True items
+ * */
+exports.WeakTrueItems = ['1', 'true', 't', 'yes', 'y', 'on'];

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

@@ -1,7 +1,8 @@
 import { Leyyo } from "../leyyo";
-import { CommonLog, CommonLogSecure, Logger, LogLine } from "./index-types";
+import { CommonLog, CommonLogSecure } from "./index-types";
+import { Logger, LogLine } from "../shared";
 export declare class CommonLogImpl implements CommonLog, CommonLogSecure {
-    private callback;
+    private hook;
     constructor();
     get $secure(): CommonLogSecure;
     $init(leyyo: Leyyo): void;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonLogImpl = void 0;
 const logger_impl_1 = require("./logger-impl");
-const constants_1 = require("../constants");
-// noinspection JSUnusedLocalSymbols
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
 class CommonLogImpl {
     constructor() {
         this.create.bind(this);
@@ -15,16 +15,16 @@ class CommonLogImpl {
         throw this;
     }
     $init(leyyo) {
-        this.callback = leyyo.callback;
+        this.hook = leyyo.hook;
         const fields = ['create', 'apply', 'check', 'print'];
         const rec = { proper: false };
         fields.forEach(field => {
             rec[field] = this[field];
         });
         // define itself temporarily for log operations
-        this.callback.defineProvider(constants_1.LY_ATTACHED_LOG, CommonLogImpl, rec);
+        this.hook.defineProvider(shared_1.LY_ATTACHED_LOG, CommonLogImpl, rec);
         // when new log provider is defined, replace all common methods
-        this.callback.whenProviderDefined(constants_1.LY_ATTACHED_LOG, CommonLogImpl, (ins) => {
+        this.hook.whenProviderDefined(shared_1.LY_ATTACHED_LOG, CommonLogImpl, (ins) => {
             fields.forEach(field => {
                 if (typeof ins[field] === 'function') {
                     this[field] = ins[field];
@@ -34,7 +34,7 @@ class CommonLogImpl {
     }
     create(clazz) {
         const ins = new logger_impl_1.LoggerImpl(clazz);
-        this.callback.queueForCallback(constants_1.LY_PENDING_LOG_REGISTER, ins, clazz);
+        this.hook.queueForCallback(shared_1.LY_PENDING_LOG_REGISTER, ins, clazz);
         return ins;
     }
     apply(line) {

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

@@ -1,55 +1,5 @@
-import { Severity } from "../literals";
-import { Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
-import { CommonCallbackDefined } from "../callback";
+import { InitLike, LogConsumer, Logger, ShiftMain, ShiftSecure } from "../shared";
 export interface CommonLog extends ShiftSecure<CommonLogSecure>, LogConsumer {
     create(clazz: Object | Function | string): Logger;
 }
-export interface CommonLogCb extends CommonCallbackDefined {
-    create?(clazz: Object | Function | string): Logger;
-    apply?(line: LogLine): void;
-    check?<T>(line: LogLineEnhanced<T>): void;
-    print<T>(line: LogLineEnhanced<T>): void;
-}
-export interface CommonLogSecure extends ShiftMain<CommonLog>, InitLike {
-}
-export interface LogConsumer {
-    apply(line: LogLine): void;
-}
-export interface LogLine {
-    severity: Severity;
-    message: string | Error;
-    holder?: string;
-    params?: Dict;
-}
-export interface LogLineEnhanced<L = Dict> extends LogLine {
-    time?: Date;
-    locals?: L;
-}
-export interface Logger extends ShiftSecure<LoggerSecure> {
-    error(message: string, params?: any): void;
-    error(error: Error, params?: any): void;
-    error(whatever: any, params?: any): void;
-    warn(message: string, params?: any): void;
-    warn(error: Error, params?: any): void;
-    warn(whatever: any, params?: any): void;
-    info(message: string, params?: any): void;
-    info(error: Error, params?: any): void;
-    info(whatever: any, params?: any): void;
-    log(message: string, params?: any): void;
-    log(error: Error, params?: any): void;
-    log(whatever: any, params?: any): void;
-    trace(message: string, params?: any): void;
-    trace(error: Error, params?: any): void;
-    trace(whatever: any, params?: any): void;
-    debug(message: string, params?: any): void;
-    debug(error: Error, params?: any): void;
-    debug(whatever: any, params?: any): void;
-}
-export interface LoggerSecure extends ShiftMain<Logger> {
-    get $clazz(): Function;
-    get $name(): string;
-    $assert(error: Error, indicator: string, params?: unknown): void;
-    $setName(name: string): void;
-    $setMethod(method: Severity, lambda?: LoggerLambda): void;
-}
-export type LoggerLambda = (whatever: any, params?: any) => void;
+export type CommonLogSecure = ShiftMain<CommonLog> & InitLike;

package/dist/log/index-types.js

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

package/dist/log/index.d.ts

@@ -1,3 +1,3 @@
 export * from './index-types';
-export * from './logger-impl';
 export * from './common-log-impl';
+export * from './logger-impl';

package/dist/log/index.js

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

package/dist/log/logger-impl.d.ts

@@ -1,10 +1,10 @@
-import { Logger, LoggerLambda, LoggerSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { Severity } from "../literals";
+import { Severity } from "../literal";
+import { Logger, LoggerLambda, LoggerSecure } from "../shared";
 export declare class LoggerImpl implements Logger, LoggerSecure {
     private readonly _clazz;
     private _name;
-    private static _callback;
+    private static _fqn;
     private static _log;
     constructor(value: Object | Function | string);
     debug(message: any, params?: any): void;

package/dist/log/logger-impl.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerImpl = void 0;
-const error_1 = require("../error");
+const exception_1 = require("../exception");
 // noinspection JSUnusedLocalSymbols
 class LoggerImpl {
     constructor(value) {
         switch (typeof value) {
             case "function":
                 this._clazz = value;
-                this._name = LoggerImpl._callback.fqnName(value);
+                this._name = LoggerImpl._fqn.name(value);
                 break;
             case "object":
                 this._clazz = value.constructor;
-                this._name = LoggerImpl._callback.fqnName(value);
+                this._name = LoggerImpl._fqn.name(value);
                 break;
             case "string":
                 this._name = value;
                 break;
             default:
-                throw new error_1.DeveloperException('invalid.logger.name', { type: typeof value });
+                throw new exception_1.DeveloperException('invalid.logger.name', { type: typeof value });
         }
     }
     debug(message, params) {
@@ -53,7 +53,7 @@ class LoggerImpl {
         return this._name;
     }
     static $setLeyyo(leyyo) {
-        this._callback = leyyo.callback;
+        this._fqn = leyyo.fqn;
         this._log = leyyo.log;
     }
     $setName(name) {

package/dist/{assertion → shared}/assert.js

@@ -1,4 +1,5 @@
 "use strict";
+// noinspection JSUnusedGlobalSymbols
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert = assert;
 exports.$$setLeyyo = $$setLeyyo;

package/dist/{aliases.d.ts → shared/index-aliases.d.ts}

@@ -1,4 +1,4 @@
-import { LanguageCode, LocaleCode } from "./literals";
+import { LanguageCode, LocaleCode } from "../literal";
 export type BasicType = 'undefined' | 'string' | 'object' | 'number' | 'boolean' | 'function' | 'symbol' | 'bigint';
 export type Dict<T = any> = Record<KeyValue, T>;
 export type Arr<T = any> = Array<T>;

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

@@ -0,0 +1,141 @@
+import { Dict, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "./index-aliases";
+import { Exception, ExceptionLike } from "../exception";
+import { Severity, StorageType } from "../literal";
+export interface AssertionOpt {
+    indicator?: AssertionReason | string;
+    param?: string;
+    where?: string;
+    value?: any;
+    expected?: OneOrMore<string>;
+    current?: string;
+    type?: string;
+    [k: string]: any;
+}
+type AssertionReason = 'invalid.type' | 'not.found' | 'duplicated' | 'empty';
+export type AssertionCallback = () => string | AssertionOpt;
+export interface AssertionBuiltResult {
+    message?: string;
+    params: AssertionOpt;
+}
+export interface HookAttachedCallback {
+    initialization?: true;
+    fn: Function;
+}
+export interface $HookDefinedProvider extends HookDefinedProvider {
+    producer: Function;
+}
+export interface HookDefinedProvider {
+    proper: boolean;
+}
+export interface HookWaitingProviderItem {
+    consumer: Function;
+    callback: HookDefinedProviderLambda;
+}
+export type HookDefinedProviderLambda<T extends HookDefinedProvider = HookDefinedProvider> = (instance: T) => void;
+export interface FqnDefinedProvider extends HookDefinedProvider {
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}
+export type FqnStereoType = 'class' | 'function' | 'enum' | 'literal';
+export interface ErrorDefinedProvider extends HookDefinedProvider {
+    register(exception: ExceptionLike): void;
+    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 LogDefinedProvider extends HookDefinedProvider {
+    create?(clazz: Object | Function | string): Logger;
+    apply?(line: LogLine): void;
+    check?<T>(line: LogLineEnhanced<T>): void;
+    print<T>(line: LogLineEnhanced<T>): void;
+}
+export interface LogConsumer {
+    apply(line: LogLine): void;
+}
+export interface LogLine {
+    severity: Severity;
+    message: string | Error;
+    holder?: string;
+    params?: Dict;
+}
+export interface LogLineEnhanced<L = Dict> extends LogLine {
+    time?: Date;
+    locals?: L;
+}
+export interface Logger extends ShiftSecure<LoggerSecure> {
+    error(message: string, params?: any): void;
+    error(error: Error, params?: any): void;
+    error(whatever: any, params?: any): void;
+    warn(message: string, params?: any): void;
+    warn(error: Error, params?: any): void;
+    warn(whatever: any, params?: any): void;
+    info(message: string, params?: any): void;
+    info(error: Error, params?: any): void;
+    info(whatever: any, params?: any): void;
+    log(message: string, params?: any): void;
+    log(error: Error, params?: any): void;
+    log(whatever: any, params?: any): void;
+    trace(message: string, params?: any): void;
+    trace(error: Error, params?: any): void;
+    trace(whatever: any, params?: any): void;
+    debug(message: string, params?: any): void;
+    debug(error: Error, params?: any): void;
+    debug(whatever: any, params?: any): void;
+}
+export interface LoggerSecure extends ShiftMain<Logger> {
+    get $clazz(): Function;
+    get $name(): string;
+    $assert(error: Error, indicator: string, params?: unknown): void;
+    $setName(name: string): void;
+    $setMethod(method: Severity, lambda?: LoggerLambda): void;
+}
+export type LoggerLambda = (whatever: any, params?: any) => void;
+/**
+ * Storage size dictionary which in corresponding type
+ * */
+export type StorageItem = Dict<number>;
+/**
+ * Storage export dictionary which includes items
+ * */
+export type StorageDetail = Record<StorageType, StorageItem>;
+export interface ToTypeOpt extends AssertionOpt {
+    silent?: true;
+    children?: unknown;
+}
+export type ToTypeFnLambda<T = unknown, O extends ToTypeOpt = ToTypeOpt> = (value: unknown, opt?: O) => T;
+export interface ToTypeChildOpt<T = unknown> extends ToTypeOpt {
+    fn?: ToTypeFnLambda<T>;
+}
+export interface ToTypeArrayChildOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends Dict<ToTypeChildOpt> {
+    value?: V;
+}
+export interface ToTypeArrayOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeArrayChildOpt<V>;
+}
+export interface ToTypeDictChildOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends Record<string, ToTypeChildOpt> {
+    key?: K;
+    value?: V;
+}
+export interface ToTypeObjectOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeDictChildOpt<K, V>;
+}
+export interface ToTypeEnumOpt<E extends KeyValue = KeyValue> extends ToTypeOpt {
+    map: EnumerationMap<E> | EnumerationArray<E>;
+    alt?: EnumerationAlt<E>;
+}
+export type EnumerationMap<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationAlt<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationArray<E extends KeyValue = KeyValue> = Array<E>;
+export {};

package/dist/shared/index-types.js

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

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './index-aliases';
+export * from './index-constants';
+export * from './index-types';
+export * from './assert';
+export * from './list';

package/dist/shared/index.js

@@ -0,0 +1,21 @@
+"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-aliases"), exports);
+__exportStar(require("./index-constants"), exports);
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./assert"), exports);
+__exportStar(require("./list"), exports);

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

@@ -1,7 +1,7 @@
-import { List } from "./list";
-import { CommonStorage, CommonStorageSecure, StorageDetail, StorageItem } from "./index-types";
+import { List, StorageDetail, StorageItem } from "../shared";
+import { CommonStorage, CommonStorageSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { StorageType } from "../literals";
+import { StorageType } from "../literal";
 /** @inheritDoc */
 export declare class CommonStorageImpl implements CommonStorage, CommonStorageSecure {
     private readonly _lists;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonStorageImpl = void 0;
-const list_1 = require("./list");
-// noinspection JSUnusedLocalSymbols
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
 /** @inheritDoc */
 class CommonStorageImpl {
     /**
@@ -80,7 +80,7 @@ class CommonStorageImpl {
     // region list
     /** @inheritDoc */
     newList(name) {
-        const list = new list_1.List();
+        const list = new shared_1.List();
         this._lists.set(name, list);
         return list;
     }

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

@@ -1,6 +1,5 @@
-import { List } from "./list";
-import { Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
-import { StorageType } from "../literals";
+import { InitLike, List, ShiftMain, ShiftSecure, StorageDetail } from "../shared";
+import { StorageType } from "../literal";
 /**
  * Storage factory
  *
@@ -85,13 +84,4 @@ export interface CommonStorage extends ShiftSecure<CommonStorageSecure> {
      * */
     details(type?: StorageType, name?: string): StorageDetail;
 }
-export interface CommonStorageSecure extends ShiftMain<CommonStorage>, InitLike {
-}
-/**
- * Storage size dictionary which in corresponding type
- * */
-export type StorageItem = Dict<number>;
-/**
- * Storage export dictionary which includes items
- * */
-export type StorageDetail = Record<StorageType, StorageItem>;
+export type CommonStorageSecure = ShiftMain<CommonStorage> & InitLike;

package/dist/storage/index.d.ts

@@ -1,3 +1,2 @@
 export * from './index-types';
-export * from './list';
 export * from './common-storage-impl';

package/dist/storage/index.js

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

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

@@ -1,5 +1,5 @@
-import { CommonTo, CommonToSecure, ToTypeArrayOpt, ToTypeEnumOpt, ToTypeObjectOpt, ToTypeOpt } from "./index-types";
-import { Dict, KeyValue, OneOrMore } from "../aliases";
+import { CommonTo, CommonToSecure } from "./index-types";
+import { Dict, KeyValue, OneOrMore, ToTypeArrayOpt, ToTypeEnumOpt, ToTypeObjectOpt, ToTypeOpt } from "../shared";
 import { Leyyo } from "../leyyo";
 export declare class CommonToImpl implements CommonTo, CommonToSecure {
     private readonly _EXPECTED_ANY;
@@ -11,7 +11,7 @@ export declare class CommonToImpl implements CommonTo, CommonToSecure {
     private readonly _EXPECTED_NUMBER;
     private readonly _EXPECTED_STRING;
     private is;
-    private callback;
+    private fqn;
     private assertion;
     private _enumInMap;
     private _enumInArray;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonToImpl = void 0;
-const literals_1 = require("../literals");
-const error_1 = require("../error");
+const literal_1 = require("../literal");
+const exception_1 = require("../exception");
 // noinspection JSUnusedGlobalSymbols
 class CommonToImpl {
     constructor() {
@@ -137,7 +137,7 @@ class CommonToImpl {
             return fn(value);
         }
         catch (e) {
-            error_1.Exception.cast(e).raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
+            exception_1.Exception.cast(e).raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
         }
         return null;
     }
@@ -150,7 +150,7 @@ class CommonToImpl {
             indicator = 'type.invalid-value';
         }
         opt = Object.assign(Object.assign(Object.assign({}, opt), params), { expected, value });
-        new error_1.DeveloperException(indicator, opt)
+        new exception_1.DeveloperException(indicator, opt)
             .with(this)
             .raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
         return null;
@@ -201,7 +201,7 @@ class CommonToImpl {
                                 result.push(valueFn(v, clonedOpt));
                             }
                             catch (e) {
-                                error_1.Exception.cast(e).raise(!opt.silent);
+                                exception_1.Exception.cast(e).raise(!opt.silent);
                                 result.push(null);
                             }
                         });
@@ -226,10 +226,10 @@ class CommonToImpl {
                 if (value === '') {
                     return null;
                 }
-                if (literals_1.WeakTrueItems.includes(value)) {
+                if (literal_1.WeakTrueItems.includes(value)) {
                     return true;
                 }
-                if (literals_1.WeakFalseItems.includes(value)) {
+                if (literal_1.WeakFalseItems.includes(value)) {
                     return false;
                 }
                 return this.raiseInvalidValue(value, this._EXPECTED_BOOL, opt);
@@ -258,7 +258,7 @@ class CommonToImpl {
                 return value;
             case 'object':
             case 'function':
-                return this.callback.fqnName(value);
+                return this.fqn.name(value);
         }
         return this.raiseInvalidValue(value, this._EXPECTED_CLASS, opt);
     }
@@ -314,7 +314,7 @@ class CommonToImpl {
             mapType = 'array';
         }
         if (!mapType) {
-            throw new error_1.DeveloperException('type.invalid-enum-items', { map: opt.map });
+            throw new exception_1.DeveloperException('type.invalid-enum-items', { map: opt.map });
         }
         let v;
         switch (typeof value) {
@@ -475,7 +475,7 @@ class CommonToImpl {
                             result[keyOpt.fn(k, keyOpt)] = valueOpt.fn(v, valueOpt);
                         }
                         catch (e) {
-                            error_1.Exception.cast(e).raise(!opt.silent);
+                            exception_1.Exception.cast(e).raise(!opt.silent);
                             result[k] = null;
                         }
                     }
@@ -540,7 +540,7 @@ class CommonToImpl {
     // region secure
     $init(leyyo) {
         this.is = leyyo.is;
-        this.callback = leyyo.callback;
+        this.fqn = leyyo.fqn;
         this.assertion = leyyo.assertion;
     }
     get $back() {