zation-assured 0.6.2 → 3.0.0-dev.3

package/dist/lib/helper/asserter/value/abstractValueAsserter.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -15,12 +15,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractValueAsserter = void 0;
-const forint_1 = require("forint");
+const queric_1 = require("queric");
 const chai_1 = require("chai");
 class AbstractValueAsserter {
-    constructor(name, addTest) {
+    constructor(addTest) {
         this.addTest = addTest;
-        this.name = name;
     }
     // noinspection JSUnusedGlobalSymbols
     /**
@@ -28,8 +27,8 @@ class AbstractValueAsserter {
      * Asserts that the value is undefined.
      */
     isUndefined() {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert(value === undefined, `${this.name + eStr} should be undefined.`);
+        this.addTest((value, target) => {
+            (0, chai_1.assert)(value === undefined, `${target} should be undefined.`);
         });
         return this.self();
     }
@@ -39,8 +38,8 @@ class AbstractValueAsserter {
      * Asserts that the value is not undefined.
      */
     isNotUndefined() {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert(value !== undefined, `${this.name + eStr} should be not undefined.`);
+        this.addTest((value, target) => {
+            (0, chai_1.assert)(value !== undefined, `${target} should be not undefined.`);
         });
         return this.self();
     }
@@ -51,8 +50,8 @@ class AbstractValueAsserter {
      * @param type
      */
     typeOf(type) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.typeOf(value, type, `${this.name + eStr} should be type of ${type}`);
+        this.addTest((value, target) => {
+            chai_1.assert.typeOf(value, type, `${target} should be type of ${type}`);
         });
         return this.self();
     }
@@ -63,8 +62,8 @@ class AbstractValueAsserter {
      * @param type
      */
     notTypeOf(type) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notTypeOf(value, type, `${this.name + eStr} should be not type of ${type}`);
+        this.addTest((value, target) => {
+            chai_1.assert.notTypeOf(value, type, `${target} should be not type of ${type}`);
         });
         return this.self();
     }
@@ -75,8 +74,8 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     contentEqual(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.equal(value, expectedValue, `${this.name + eStr} should be content equal with ${expectedValue}`);
+        this.addTest((value, target) => {
+            chai_1.assert.equal(value, expectedValue, `${target} should be content equal with ${expectedValue}`);
         });
         return this.self();
     }
@@ -87,8 +86,8 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     notContentEqual(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notEqual(value, expectedValue, `${this.name + eStr} should be not content equal with ${expectedValue}`);
+        this.addTest((value, target) => {
+            chai_1.assert.notEqual(value, expectedValue, `${target} should be not content equal with ${expectedValue}`);
         });
         return this.self();
     }
@@ -99,8 +98,8 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     equal(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.strictEqual(value, expectedValue, `${this.name + eStr} should be strict equal with ${expectedValue}`);
+        this.addTest((value, target) => {
+            chai_1.assert.strictEqual(value, expectedValue, `${target} should be strict equal with ${expectedValue}`);
         });
         return this.self();
     }
@@ -111,8 +110,8 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     notEqual(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notStrictEqual(value, expectedValue, `${this.name + eStr} should be not strict equal with ${expectedValue}`);
+        this.addTest((value, target) => {
+            chai_1.assert.notStrictEqual(value, expectedValue, `${target} should be not strict equal with ${expectedValue}`);
         });
         return this.self();
     }
@@ -123,8 +122,8 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     deepEqual(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.deepEqual(value, expectedValue, `${this.name + eStr} should be deep strict equal with ${JSON.stringify(expectedValue)}`);
+        this.addTest((value, target) => {
+            chai_1.assert.deepEqual(value, expectedValue, `${target} should be deep strict equal with ${JSON.stringify(expectedValue)}`);
         });
         return this.self();
     }
@@ -135,28 +134,28 @@ class AbstractValueAsserter {
      * @param expectedValue
      */
     notDeepEqual(expectedValue) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notDeepEqual(value, expectedValue, `${this.name + eStr} should be not deep strict equal with ${JSON.stringify(expectedValue)}`);
+        this.addTest((value, target) => {
+            chai_1.assert.notDeepEqual(value, expectedValue, `${target} should be not deep strict equal with ${JSON.stringify(expectedValue)}`);
         });
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
     /**
-     * Asserts that the value matches with a forint query.
+     * Asserts that the value matches with a queric query.
      */
     matches(query) {
-        this.addTest((inAny, eStr = '') => __awaiter(this, void 0, void 0, function* () {
-            yield chai_1.assert(forint_1.default(query)(inAny), `${this.name + eStr} should match with the forint query.`);
+        this.addTest((inAny, target) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, chai_1.assert)((0, queric_1.default)(query)(inAny), `${target} should match with the queric query.`);
         }));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
     /**
-     * Asserts that the value not matches with a forint query.
+     * Asserts that the value not matches with a queric query.
      */
     notMatches(query) {
-        this.addTest((inAny, eStr = '') => __awaiter(this, void 0, void 0, function* () {
-            yield chai_1.assert(!forint_1.default(query)(inAny), `${this.name + eStr} should not match with the forint query.`);
+        this.addTest((inAny, target) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, chai_1.assert)(!(0, queric_1.default)(query)(inAny), `${target} should not match with the queric query.`);
         }));
         return this.self();
     }
@@ -167,8 +166,8 @@ class AbstractValueAsserter {
      * @param keys
      */
     containsAllKeys(...keys) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.containsAllKeys(value, keys, `${this.name + eStr} should contain all following keys: ${keys}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.containsAllKeys(value, keys, `${target} should contain all following keys: ${keys}.`);
         });
         return this.self();
     }
@@ -179,8 +178,8 @@ class AbstractValueAsserter {
      * @param keys
      */
     hasAnyKeys(...keys) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.hasAnyKeys(value, keys, `${this.name + eStr} should contain at least one of these keys: ${keys}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.hasAnyKeys(value, keys, `${target} should contain at least one of these keys: ${keys}.`);
         });
         return this.self();
     }
@@ -191,8 +190,8 @@ class AbstractValueAsserter {
      * @param keys
      */
     doesNotHaveAnyKeys(...keys) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.doesNotHaveAnyKeys(value, keys, `${this.name + eStr} should not contain any of these keys: ${keys}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.doesNotHaveAnyKeys(value, keys, `${target} should not contain any of these keys: ${keys}.`);
         });
         return this.self();
     }
@@ -205,8 +204,8 @@ class AbstractValueAsserter {
      * @param subset
      */
     ownInclude(subset) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.ownInclude(value, subset, `${this.name + eStr} should own include ${JSON.stringify(subset)}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.ownInclude(value, subset, `${target} should own include ${JSON.stringify(subset)}.`);
         });
         return this.self();
     }
@@ -219,8 +218,8 @@ class AbstractValueAsserter {
      * @param subset
      */
     notOwnInclude(subset) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notOwnInclude(value, subset, `${this.name + eStr} should not own include ${JSON.stringify(subset)}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.notOwnInclude(value, subset, `${target} should not own include ${JSON.stringify(subset)}.`);
         });
         return this.self();
     }
@@ -234,8 +233,8 @@ class AbstractValueAsserter {
      * @param subset
      */
     include(subset) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.include(value, subset, `${this.name + eStr} should include ${JSON.stringify(subset)}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.include(value, subset, `${target} should include ${JSON.stringify(subset)}.`);
         });
         return this.self();
     }
@@ -249,8 +248,8 @@ class AbstractValueAsserter {
      * @param subset
      */
     notInclude(subset) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.notInclude(value, subset, `${this.name + eStr} should not include ${JSON.stringify(subset)}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.notInclude(value, subset, `${target} should not include ${JSON.stringify(subset)}.`);
         });
         return this.self();
     }
@@ -261,22 +260,19 @@ class AbstractValueAsserter {
      * @param length
      */
     lengthOf(length) {
-        this.addTest((value, eStr = '') => {
-            chai_1.assert.lengthOf(value, length, `${this.name + eStr} should have a length of ${length}.`);
+        this.addTest((value, target) => {
+            chai_1.assert.lengthOf(value, length, `${target} should have a length of ${length}.`);
         });
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Lets you do a custom assertion with the value.
+     * Creates a custom assertion.
      * @param assert
-     * @param message
      */
-    assert(assert, message = 'Custom assertion should return true.') {
-        this.addTest((value, eStr = '') => __awaiter(this, void 0, void 0, function* () {
-            chai_1.assert(yield assert(value), `${this.name + eStr}: ${message}`);
-        }));
+    assert(assert) {
+        this.addTest((value, target) => assert(value, target));
         return this.self();
     }
 }

package/dist/lib/helper/asserter/value/standaloneValueAsserter.d.ts

@@ -1,12 +1,12 @@
 import { AbstractValueAsserter } from "./abstractValueAsserter";
 import { Test } from "../../test/test";
-export declare class StandaloneValueAsserter extends AbstractValueAsserter<StandaloneValueAsserter> {
+export declare class StandaloneValueAsserter<V> extends AbstractValueAsserter<V, StandaloneValueAsserter<V>> {
     protected _test: Test;
-    constructor(value: any, itTestDescription?: string);
+    constructor(value: V, description?: string);
     /**
      * @description
      * Run the test.
      */
     test(): Promise<void>;
-    protected self(): StandaloneValueAsserter;
+    protected self(): StandaloneValueAsserter<V>;
 }

package/dist/lib/helper/asserter/value/standaloneValueAsserter.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -18,11 +18,11 @@ exports.StandaloneValueAsserter = void 0;
 const abstractValueAsserter_1 = require("./abstractValueAsserter");
 const test_1 = require("../../test/test");
 class StandaloneValueAsserter extends abstractValueAsserter_1.AbstractValueAsserter {
-    constructor(value, itTestDescription) {
-        super('CustomValue', (test) => {
-            this._test.test(() => test(value));
+    constructor(value, description) {
+        super((test) => {
+            this._test.test(() => test(value, 'Value'));
         });
-        this._test = new test_1.Test(itTestDescription);
+        this._test = new test_1.Test(description);
     }
     // noinspection JSUnusedGlobalSymbols
     /**

package/dist/lib/helper/asserter/value/valueAsserter.d.ts

@@ -1,13 +1,13 @@
 import { AbstractValueAsserter } from "./abstractValueAsserter";
-declare type AddTest = (test: (value: any, eStr?: string) => void) => void;
-export declare class ValueAsserter<T> extends AbstractValueAsserter<ValueAsserter<T>> {
+declare type AddTest = (test: (value: any, target: string) => void) => void;
+export declare class ValueAsserter<V, T> extends AbstractValueAsserter<V, ValueAsserter<V, T>> {
     protected readonly _source: T;
-    constructor(source: T, name: string, addTest: AddTest);
+    constructor(source: T, addTest: AddTest);
     /**
      * @description
      * End the value asserter.
      */
     end(): T;
-    protected self(): ValueAsserter<T>;
+    protected self(): ValueAsserter<V, T>;
 }
 export {};

package/dist/lib/helper/asserter/value/valueAsserter.js

@@ -1,15 +1,15 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueAsserter = void 0;
 const abstractValueAsserter_1 = require("./abstractValueAsserter");
 class ValueAsserter extends abstractValueAsserter_1.AbstractValueAsserter {
-    constructor(source, name, addTest) {
-        super(name, addTest);
+    constructor(source, addTest) {
+        super(addTest);
         this._source = source;
     }
     // noinspection JSUnusedGlobalSymbols

package/dist/lib/helper/backError/backErrorsFilterBuilder.d.ts

@@ -0,0 +1,12 @@
+import { AbstractBackErrorsFilterBuilder, BackErrorFilter } from "zation-client";
+export declare class BackErrorsFilterBuilder<T> extends AbstractBackErrorsFilterBuilder<BackErrorsFilterBuilder<T>> {
+    private readonly _source;
+    private readonly _filterCallback;
+    constructor(source: T, filterCallback: (filter: BackErrorFilter) => void);
+    /**
+     * @description
+     * Ends the filter builder.
+     */
+    end(): T;
+    protected self(): BackErrorsFilterBuilder<T>;
+}

package/dist/lib/helper/backError/backErrorsFilterBuilder.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+Copyright(c) Ing. Luca Gian Scaringella
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackErrorsFilterBuilder = void 0;
+const zation_client_1 = require("zation-client");
+class BackErrorsFilterBuilder extends zation_client_1.AbstractBackErrorsFilterBuilder {
+    constructor(source, filterCallback) {
+        super();
+        this._source = source;
+        this._filterCallback = filterCallback;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Ends the filter builder.
+     */
+    end() {
+        this._filterCallback(this.buildFilter() || {});
+        return this._source;
+    }
+    self() {
+        return this;
+    }
+}
+exports.BackErrorsFilterBuilder = BackErrorsFilterBuilder;

package/dist/lib/helper/console/logger.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;

package/dist/lib/helper/definitions/optionTypes.d.ts

@@ -0,0 +1,8 @@
+import { ApiLevelOption, ResponseTimeoutOption } from "zation-client";
+import { ComplexTypesOption, BatchOption, SendTimeoutOption } from 'ziron-client';
+export interface RequestOptions extends SendTimeoutOption, ApiLevelOption, ResponseTimeoutOption, BatchOption, ComplexTypesOption {
+}
+export interface ValidationRequestOptions extends SendTimeoutOption, ApiLevelOption, ResponseTimeoutOption, BatchOption, ComplexTypesOption {
+}
+export default interface TransmitOptions extends SendTimeoutOption, ApiLevelOption, BatchOption, ComplexTypesOption {
+}

package/dist/lib/helper/definitions/optionTypes.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+Copyright(c) Ing. Luca Gian Scaringella
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/helper/test/test.d.ts

@@ -2,8 +2,8 @@ declare type Action = () => Promise<void> | void;
 export declare class Test {
     private readonly _subTests;
     private currentSubTest;
-    private readonly _testItDescription?;
-    constructor(testItDescription?: string);
+    private readonly _description?;
+    constructor(description?: string);
     newSubTest(): void;
     beforeTest(action: Action): void;
     test(action: Action): void;

package/dist/lib/helper/test/test.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -17,9 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Test = void 0;
 const waitSymbol = Symbol();
 class Test {
-    constructor(testItDescription) {
+    constructor(description) {
         this._subTests = [];
-        this._testItDescription = testItDescription;
+        this._description = description;
         this.newSubTest();
     }
     newSubTest() {
@@ -49,9 +49,11 @@ class Test {
     }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._testItDescription != null) {
+            if (this._description != null) {
+                if (global['it'] == null)
+                    throw new Error("Please install a test runner like mocha or jest.");
                 return new Promise((resolve, reject) => {
-                    it(this._testItDescription, () => __awaiter(this, void 0, void 0, function* () {
+                    global['it'](this._description, () => __awaiter(this, void 0, void 0, function* () {
                         try {
                             yield this._run();
                             resolve();

package/dist/lib/helper/timeout/timeoutAssert.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }

package/dist/lib/helper/utils/actionUtils.d.ts

@@ -1,24 +1,11 @@
-import { Test } from "../test/test";
 export default class ActionUtils {
     /**
      * @description
-     * This function lets you do an extra action and asserts that no error is thrown.
-     * When an error throws, it lets the test fail with the provided message or the concrete error.
-     * @param test
+     * Runs a test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
      * @param func
-     * @param failMsg if not provided it throws the specific error.
+     * @param failMsg If not provided, the concrete error is used.
      */
-    static action(test: Test, func: () => void | Promise<void>, failMsg?: string): void;
-    /**
-     * @description
-     * This function lets you do an extra action and
-     * asserts that an error or an error instance of a specific class is thrown.
-     * When no error is thrown, or the error does not match with the given classes
-     * (only if at least one class is given), it lets the test fail with the provided message.
-     * @param test
-     * @param func
-     * @param message
-     * @param validErrorClasses
-     */
-    static actionShouldThrow(test: Test, func: () => void | Promise<void>, message: string, ...validErrorClasses: any[]): void;
+    static runAction(func: () => void | Promise<void>, failMsg?: string): Promise<void>;
 }

package/dist/lib/helper/utils/actionUtils.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -14,57 +14,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const assert = require('assert');
+const assert_1 = require("assert");
 class ActionUtils {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * This function lets you do an extra action and asserts that no error is thrown.
-     * When an error throws, it lets the test fail with the provided message or the concrete error.
-     * @param test
+     * Runs a test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
      * @param func
-     * @param failMsg if not provided it throws the specific error.
+     * @param failMsg If not provided, the concrete error is used.
      */
-    static action(test, func, failMsg) {
-        test.test(() => __awaiter(this, void 0, void 0, function* () {
+    static runAction(func, failMsg) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield func();
             }
-            catch (e) {
-                assert.fail(failMsg !== undefined ? failMsg : e);
+            catch (err) {
+                if (err instanceof assert_1.AssertionError)
+                    throw err;
+                (0, assert_1.fail)(failMsg != null ? failMsg : err);
             }
-        }));
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * This function lets you do an extra action and
-     * asserts that an error or an error instance of a specific class is thrown.
-     * When no error is thrown, or the error does not match with the given classes
-     * (only if at least one class is given), it lets the test fail with the provided message.
-     * @param test
-     * @param func
-     * @param message
-     * @param validErrorClasses
-     */
-    static actionShouldThrow(test, func, message, ...validErrorClasses) {
-        test.test(() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield func();
-                assert.fail(message);
-            }
-            catch (e) {
-                let found = validErrorClasses.length === 0;
-                for (let i = 0; i < validErrorClasses.length; i++) {
-                    if (e instanceof validErrorClasses[i]) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found)
-                    assert.fail(message);
-            }
-        }));
+        });
     }
 }
 exports.default = ActionUtils;

package/dist/lib/helper/utils/types.d.ts

@@ -0,0 +1,20 @@
+import { Channel, Client, Databox, Response } from "zation-client";
+export declare type ClientAPI<T extends Client<any, any>> = T extends Client<infer API, any> ? API : never;
+export declare type ClientTokenPayload<T extends Client<any, any>> = T extends Client<any, infer TP> ? TP : never;
+export declare type ResponseData<T extends Response<any>> = T extends Response<infer D> ? D : never;
+export declare type DataboxData<T extends Databox<any, any, any, any>> = T extends Databox<infer D, any, any, any> ? D : never;
+export declare type DataboxMember<T extends Databox<any, any, any, any>> = T extends Databox<any, infer M, any, any> ? M : never;
+export declare type DataboxFetchData<T extends Databox<any, any, any, any>> = T extends Databox<any, any, any, infer F> ? F : never;
+export declare type ChannelMember<T extends Channel<any, any>> = T extends Channel<infer M, any> ? M : never;
+export declare type ChannelEvents<T extends Channel<any, any>> = T extends Channel<any, infer E> ? E : never;
+export declare type Primitive = undefined | null | boolean | string | number | Function;
+export declare type DeepReadonly<T> = T extends Primitive ? T : T extends Array<infer U> ? DeepReadonlyArray<U> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : DeepReadonlyObject<T>;
+interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {
+}
+interface DeepReadonlyMap<K, V> extends ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> {
+}
+declare type DeepReadonlyObject<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+export declare type Default<T, D> = T extends undefined ? D : T;
+export {};

package/dist/lib/helper/utils/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+Copyright(c) Ing. Luca Gian Scaringella
+ */
+Object.defineProperty(exports, "__esModule", { value: true });