@atlantjs/arch 9.1.2 → 10.0.0

package/@tool-box/tests/{entity-builder.util.d.ts → builder.abstract.util.d.ts}

@@ -1,5 +1,5 @@
 type ModifierCallback<T> = (dataToModify: T) => void;
-export declare abstract class EntityBuilder<T, TBuilder extends EntityBuilder<T, TBuilder>> {
+export declare abstract class BuilderAbstract<T, TBuilder extends BuilderAbstract<T, TBuilder>> {
     private readonly innerType;
     protected modifiers: Array<ModifierCallback<T>>;
     protected constructor(innerType: new (...args: any[]) => TBuilder);

package/@tool-box/tests/{entity-builder.util.js → builder.abstract.util.js}

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityBuilder = void 0;
-class EntityBuilder {
+export class BuilderAbstract {
+    innerType;
+    modifiers = [];
     constructor(innerType) {
         this.innerType = innerType;
-        this.modifiers = [];
     }
     build() {
         const instance = this.buildDefault();
@@ -36,4 +34,3 @@ class EntityBuilder {
         return newBuilder;
     }
 }
-exports.EntityBuilder = EntityBuilder;

package/@tool-box/tests/builders/failures/dummies/failure.edge.dummy.d.ts

@@ -0,0 +1,3 @@
+import { FailureSketchEdge } from "../../../../../objects/failure/edges/failure.sketch.edge";
+export declare class FailureEdgeDummy extends FailureSketchEdge {
+}

package/@tool-box/tests/builders/failures/dummies/failure.edge.dummy.js

@@ -0,0 +1,3 @@
+import { FailureSketchEdge } from "../../../../../objects/failure/edges/failure.sketch.edge";
+export class FailureEdgeDummy extends FailureSketchEdge {
+}

package/@tool-box/tests/builders/failures/failure.edge.builder.d.ts

@@ -0,0 +1,6 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+export declare class FailureEdgeBuilder<T> extends BuilderAbstract<T, FailureEdgeBuilder<T>> {
+    private instance;
+    constructor(entityClass: new (...args: any[]) => T);
+    protected buildDefault(): T;
+}

package/@tool-box/tests/builders/failures/failure.edge.builder.js

@@ -0,0 +1,18 @@
+import { FailureEdgeDummy } from "./dummies/failure.edge.dummy";
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { faker } from "../../faker/faker";
+export class FailureEdgeBuilder extends BuilderAbstract {
+    instance;
+    constructor(entityClass) {
+        super(FailureEdgeBuilder);
+        this.instance = entityClass;
+    }
+    buildDefault() {
+        const dummy = new FailureEdgeDummy({
+            failureClass: FailureEdgeBuilder,
+            message: faker.lorem.words(),
+        });
+        Object.assign(dummy, this.instance);
+        return dummy;
+    }
+}

package/@tool-box/tests/builders/user/email.edge.builder.d.ts

@@ -0,0 +1,6 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { EmailEdge } from "../../../../objects/@common/edges/email.edge";
+export declare class EmailEdgeBuilder extends BuilderAbstract<EmailEdge, EmailEdgeBuilder> {
+    constructor();
+    protected buildDefault(): EmailEdge;
+}

package/@tool-box/tests/builders/user/email.edge.builder.js

@@ -0,0 +1,11 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { faker } from "../../faker/faker";
+import { EmailEdge } from "../../../../objects/@common/edges/email.edge";
+export class EmailEdgeBuilder extends BuilderAbstract {
+    constructor() {
+        super(EmailEdgeBuilder);
+    }
+    buildDefault() {
+        return new EmailEdge(faker.internet.email());
+    }
+}

package/@tool-box/tests/builders/user/person-name.edge.builder.d.ts

@@ -0,0 +1,6 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { PersonNameEdge } from "../../../../objects/@common/edges/person-name.edge";
+export declare class PersonNameEdgeBuilder extends BuilderAbstract<PersonNameEdge, PersonNameEdgeBuilder> {
+    constructor();
+    protected buildDefault(): PersonNameEdge;
+}

package/@tool-box/tests/builders/user/person-name.edge.builder.js

@@ -0,0 +1,11 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { faker } from "../../faker/faker";
+import { PersonNameEdge } from "../../../../objects/@common/edges/person-name.edge";
+export class PersonNameEdgeBuilder extends BuilderAbstract {
+    constructor() {
+        super(PersonNameEdgeBuilder);
+    }
+    buildDefault() {
+        return new PersonNameEdge(faker.person.fullName());
+    }
+}

package/@tool-box/tests/builders/user/username.edge.builder.d.ts

@@ -0,0 +1,6 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { UsernameEdge } from "../../../../objects/@common/edges/username.edge";
+export declare class UsernameEdgeBuilder extends BuilderAbstract<UsernameEdge, UsernameEdgeBuilder> {
+    constructor();
+    protected buildDefault(): UsernameEdge;
+}

package/@tool-box/tests/builders/user/username.edge.builder.js

@@ -0,0 +1,11 @@
+import { BuilderAbstract } from "../../builder.abstract.util";
+import { faker } from "../../faker/faker";
+import { UsernameEdge } from "../../../../objects/@common/edges/username.edge";
+export class UsernameEdgeBuilder extends BuilderAbstract {
+    constructor() {
+        super(UsernameEdgeBuilder);
+    }
+    buildDefault() {
+        return new UsernameEdge(faker.internet.username());
+    }
+}

package/@tool-box/tests/create-fake-command.d.ts

@@ -0,0 +1,9 @@
+import { Return } from "../utils/ducts/return-type";
+import { FailureSketchEdge } from "../../objects/failure/edges/failure.sketch.edge";
+export declare class CreateFakeCommand {
+    private _response;
+    static new<UsecaseStub>(): UsecaseStub & CreateFakeCommand;
+    protected execute(): Promise<Return<unknown, unknown>>;
+    withSuccess(response: unknown): this;
+    withFailure(response?: FailureSketchEdge): this;
+}

package/@tool-box/tests/create-fake-command.js

@@ -0,0 +1,23 @@
+import { FailureEdgeDummy } from "./builders/failures/dummies/failure.edge.dummy";
+import { FailureEdgeBuilder } from "./builders/failures/failure.edge.builder";
+import { Failure, Success } from "../utils/ducts/return-type";
+export class CreateFakeCommand {
+    _response;
+    static new() {
+        const instance = new CreateFakeCommand();
+        return instance;
+    }
+    async execute() {
+        if (this._response.hasFailure())
+            return Failure(this._response.unwrapFail());
+        return Success(this._response.unwrap());
+    }
+    withSuccess(response) {
+        this._response = Success(response);
+        return this;
+    }
+    withFailure(response) {
+        this._response = Failure(response ?? new FailureEdgeBuilder(FailureEdgeDummy).build());
+        return this;
+    }
+}

package/@tool-box/tests/faker/faker.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.faker = void 0;
-exports.faker = {
+export const faker = {
     date: {
         past: ({ yearsAgo = 1 } = {}) => {
             const date = new Date();
@@ -35,15 +32,15 @@ exports.faker = {
         productDescription: ({ lines = 3 } = {}) => {
             const result = [];
             for (let i = 0; i < lines; i++) {
-                result.push(exports.faker.lorem.paragraph());
+                result.push(faker.lorem.paragraph());
             }
             return result.join("\n");
         }
     },
     image: {
         url: () => {
-            const width = exports.faker.number.int({ min: 100, max: 1000 });
-            const height = exports.faker.number.int({ min: 100, max: 1000 });
+            const width = faker.number.int({ min: 100, max: 1000 });
+            const height = faker.number.int({ min: 100, max: 1000 });
             return `https://via.placeholder.com/${width}x${height}`;
         }
     },
@@ -81,7 +78,7 @@ exports.faker = {
             return lastNames[Math.floor(Math.random() * lastNames.length)];
         },
         fullName: () => {
-            return `${exports.faker.person.firstName()} ${exports.faker.person.lastName()}`;
+            return `${faker.person.firstName()} ${faker.person.lastName()}`;
         },
     },
     internet: {
@@ -91,7 +88,7 @@ exports.faker = {
         },
         email: () => {
             const domains = ["example.com", "test.com", "demo.com", "sample.com"];
-            return `${exports.faker.internet.username()}@${domains[Math.floor(Math.random() * domains.length)]}`;
+            return `${faker.internet.username()}@${domains[Math.floor(Math.random() * domains.length)]}`;
         },
         url: () => {
             const protocols = ["http", "https"];
@@ -117,7 +114,7 @@ exports.faker = {
         paragraph: ({ sentences = 5 } = {}) => {
             const result = [];
             for (let i = 0; i < sentences; i++) {
-                result.push(exports.faker.lorem.words({ count: Math.floor(Math.random() * 10) + 5 }));
+                result.push(faker.lorem.words({ count: Math.floor(Math.random() * 10) + 5 }));
             }
             return result.join(". ") + ".";
         }

package/@tool-box/utils/datatypes/boolean-utils.d.ts

@@ -2,6 +2,7 @@ interface Boolean {
     truthy(): boolean;
     falsy(): boolean;
     equal(value: boolean): boolean;
+    different(value: boolean): boolean;
     not(): boolean;
     and(value: boolean): boolean;
     or(value: boolean): boolean;

package/@tool-box/utils/datatypes/boolean-utils.js

@@ -9,11 +9,14 @@ Boolean.prototype.not = function () {
     return !this.valueOf();
 };
 Boolean.prototype.and = function (value) {
-    return this.valueOf() && value;
+    return this.valueOf() === true && value === true;
 };
 Boolean.prototype.or = function (value) {
-    return this.valueOf() || value;
+    return this.valueOf() === true || value === true;
 };
 Boolean.prototype.equal = function (value) {
     return this === value;
 };
+Boolean.prototype.different = function (value) {
+    return this !== value;
+};

package/@tool-box/utils/datatypes/generic-types.d.ts

@@ -1,7 +1,7 @@
 declare const emptyObject: {};
 export type Newable<T> = new (...args: any[]) => T;
 export type ObjectType = typeof emptyObject;
-export interface Abstract<T> {
+export interface Sketch<T> {
     prototype: T;
 }
 export {};

package/@tool-box/utils/datatypes/generic-types.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const emptyObject = {};
+export {};

package/@tool-box/utils/datatypes/string-utils.d.ts

@@ -2,14 +2,12 @@ interface String {
     toKebabCase(): string;
     toSnakeCase(): string;
     toPascalCase(): string;
-    reverse(): string;
-    trimSpaces(): string;
+    sanitize(): string;
     capitalize(): string;
     toTitleCase(): string;
     contains(substring: string): boolean;
     truncate(length: number): String;
     removeWhitespace(): string;
-    toArray(): string[];
     isEmpty(): boolean;
     fromBase64(): string;
 }

package/@tool-box/utils/datatypes/string-utils.js

@@ -8,10 +8,7 @@ String.prototype.toSnakeCase = function () {
 String.prototype.toPascalCase = function () {
     return this.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match) => match.toUpperCase()).replace(/\s+/g, "");
 };
-String.prototype.reverse = function () {
-    return this.split("").reverse().join("");
-};
-String.prototype.trimSpaces = function () {
+String.prototype.sanitize = function () {
     return this.replace(/\s+/g, " ").trim();
 };
 String.prototype.capitalize = function () {
@@ -19,9 +16,6 @@ String.prototype.capitalize = function () {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join(" ");
 };
-String.prototype.toTitleCase = function () {
-    return this.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.substr(1).toLowerCase());
-};
 String.prototype.contains = function (substring) {
     return this.indexOf(substring) !== -1;
 };
@@ -33,9 +27,6 @@ String.prototype.truncate = function (length) {
 String.prototype.removeWhitespace = function () {
     return this.replace(/\s+/g, "");
 };
-String.prototype.toArray = function () {
-    return this.split("");
-};
 String.prototype.isEmpty = function () {
     return this.length === 0;
 };

package/@tool-box/utils/ducts/common.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyArray = exports.FnVal = exports.ValueReturn = exports.SuccessReturn = void 0;
-exports.isTruthy = isTruthy;
-const guardian_1 = require("../type-guard/guardian");
-exports.SuccessReturn = Symbol("SuccessReturn");
-exports.ValueReturn = Symbol("ValueReturn");
-exports.FnVal = Symbol("FnVal");
-exports.EmptyArray = Object.freeze([]);
-function isTruthy(val) {
+import { _ } from "../type-guard/guardian";
+export const SuccessReturn = Symbol("SuccessReturn");
+export const ValueReturn = Symbol("ValueReturn");
+export const FnVal = Symbol("FnVal");
+export const EmptyArray = Object.freeze([]);
+export function isTruthy(val) {
     return val instanceof Date
-        ? guardian_1.Guardian.isEqual(val.getTime(), val.getTime())
+        ? _.isEqual(val.getTime(), val.getTime())
         : !!val;
 }

package/@tool-box/utils/ducts/optional-type.d.ts

@@ -20,6 +20,5 @@ declare class OptionalType<T> {
     unpackOrElse(this: Optional<T>, f: () => T): T;
 }
 export declare function Optional<T>(val: T): Optional<From<T>>;
-export declare function Something<T>(val: T): Something<T>;
 export declare const Nothing: Readonly<OptionalType<never>>;
 export {};

package/@tool-box/utils/ducts/optional-type.js

@@ -1,50 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Nothing = void 0;
-exports.Optional = Optional;
-exports.Something = Something;
-const common_1 = require("./common");
+import { EmptyArray, SuccessReturn, ValueReturn, isTruthy, } from "./common";
 class OptionalType {
+    [SuccessReturn];
+    [ValueReturn];
     constructor(val, something) {
-        this[common_1.SuccessReturn] = something;
-        this[common_1.ValueReturn] = val;
+        this[SuccessReturn] = something;
+        this[ValueReturn] = val;
     }
     [Symbol.iterator]() {
-        return this[common_1.SuccessReturn]
-            ? this[common_1.ValueReturn][Symbol.iterator]()
-            : common_1.EmptyArray[Symbol.iterator]();
+        return this[SuccessReturn]
+            ? this[ValueReturn][Symbol.iterator]()
+            : EmptyArray[Symbol.iterator]();
     }
     hasSomething() {
-        return this[common_1.SuccessReturn];
+        return this[SuccessReturn];
     }
     hasNothing() {
-        return !this[common_1.SuccessReturn];
+        return !this[SuccessReturn];
     }
     unpack() {
-        if (this[common_1.SuccessReturn]) {
-            return this[common_1.ValueReturn];
+        if (this[SuccessReturn]) {
+            return this[ValueReturn];
         }
         throw new Error("Failed to unpack optional value. There is nothing in here");
     }
     unpackAnyway() {
-        return this[common_1.ValueReturn];
+        return this[ValueReturn];
     }
     unpackOr(def) {
-        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : def;
+        return this[SuccessReturn] ? this[ValueReturn] : def;
     }
     unpackOrElse(f) {
-        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : f();
+        return this[SuccessReturn] ? this[ValueReturn] : f();
     }
 }
-function Optional(val) {
+export function Optional(val) {
     return from(val);
 }
 function Something(val) {
     return new OptionalType(val, true);
 }
-exports.Nothing = Object.freeze(new OptionalType(undefined, false));
+export const Nothing = Object.freeze(new OptionalType(undefined, false));
 function from(val) {
-    return (0, common_1.isTruthy)(val) && !(val instanceof Error)
+    return isTruthy(val) && !(val instanceof Error)
         ? Something(val)
-        : exports.Nothing;
+        : Nothing;
 }

package/@tool-box/utils/ducts/return-type.d.ts

@@ -1,5 +1,5 @@
-import { FailureAbstract } from "../../../arch/modules/application/failures/failure.abstract";
 import { FalseyValues, IterType, SuccessReturn, ValueReturn } from "./common";
+import { FailureSketchEdge } from "../../../objects/failure/edges/failure.sketch.edge";
 export type Success<SuccessReturn> = ReturnType<SuccessReturn, never>;
 export type Failure<FailureReturn> = ReturnType<never, FailureReturn>;
 export type Return<T, E> = ReturnType<T, E>;
@@ -18,5 +18,5 @@ export declare class ReturnType<SuccessReturn, FailureReturn> {
 }
 export declare function Return<T>(val: T): Return<From<T>, (T extends Error ? T : never) | (Extract<FalseyValues, T> extends never ? never : null)>;
 export declare function Success<SuccessReturn>(successValue?: SuccessReturn): Success<SuccessReturn>;
-export declare function Failure<FailureReturn extends FailureAbstract | null | undefined>(failureValue?: FailureReturn): Failure<FailureReturn>;
+export declare function Failure<FailureReturn extends FailureSketchEdge | null | undefined>(failureValue?: FailureReturn): Failure<FailureReturn>;
 export {};

package/@tool-box/utils/ducts/return-type.js

@@ -1,57 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturnType = void 0;
-exports.Return = Return;
-exports.Success = Success;
-exports.Failure = Failure;
-const common_1 = require("./common");
-class ReturnType {
+import { EmptyArray, SuccessReturn, ValueReturn, isTruthy, } from "./common";
+export class ReturnType {
+    [SuccessReturn];
+    [ValueReturn];
     constructor(value, hasSuccess) {
-        this[common_1.ValueReturn] = value;
-        this[common_1.SuccessReturn] = hasSuccess;
+        this[ValueReturn] = value;
+        this[SuccessReturn] = hasSuccess;
     }
     [Symbol.iterator]() {
-        return this[common_1.SuccessReturn]
-            ? this[common_1.ValueReturn][Symbol.iterator]()
-            : common_1.EmptyArray[Symbol.iterator]();
+        return this[SuccessReturn]
+            ? this[ValueReturn][Symbol.iterator]()
+            : EmptyArray[Symbol.iterator]();
     }
     hasSuccess() {
-        return this[common_1.SuccessReturn];
+        return this[SuccessReturn];
     }
     hasFailure() {
-        return !this[common_1.SuccessReturn];
+        return !this[SuccessReturn];
     }
     unwrap() {
-        if (this[common_1.SuccessReturn]) {
-            return this[common_1.ValueReturn];
+        if (this[SuccessReturn]) {
+            return this[ValueReturn];
         }
         throw new Error("Failed to unwrap Return. There is failure in here");
     }
     unwrapFail() {
-        if (this[common_1.SuccessReturn]) {
+        if (this[SuccessReturn]) {
             throw new Error("Failed to unwrapFail Return. There is success in here");
         }
-        return this[common_1.ValueReturn];
+        return this[ValueReturn];
     }
     unwrapOr(def) {
-        return this[common_1.SuccessReturn] ? this[common_1.ValueReturn] : def;
+        return this[SuccessReturn] ? this[ValueReturn] : def;
     }
     unwrapAnyway() {
-        return this[common_1.ValueReturn];
+        return this[ValueReturn];
     }
 }
-exports.ReturnType = ReturnType;
-function Return(val) {
+export function Return(val) {
     return from(val);
 }
-function Success(successValue) {
+export function Success(successValue) {
     return new ReturnType(successValue, true);
 }
-function Failure(failureValue) {
+export function Failure(failureValue) {
     return new ReturnType(failureValue, false);
 }
 function from(val) {
-    return (0, common_1.isTruthy)(val)
+    return isTruthy(val)
         ? new ReturnType(val, !(val instanceof Error))
         : Failure(null);
 }

package/@tool-box/utils/{arrays/extended-map.d.ts → map/map.abstract.d.ts}

@@ -1,5 +1,4 @@
-export declare class ExtendedMap<K, V> extends Map<K, V> {
+export declare abstract class MapAbstract<K, V> extends Map<K, V> {
     getOrDefault(key: K, defaultValue: V): V;
     getOrThrow(key: K, errorMessage?: string): V;
-    invert(): ExtendedMap<V, K>;
 }

package/@tool-box/utils/map/map.abstract.js

@@ -0,0 +1,13 @@
+import { _ } from "../type-guard/guardian";
+export class MapAbstract extends Map {
+    getOrDefault(key, defaultValue) {
+        return this.get(key) ?? defaultValue;
+    }
+    getOrThrow(key, errorMessage = "Key not mapped") {
+        const value = this.get(key);
+        if (_.isUndefined(value)) {
+            throw Error(errorMessage);
+        }
+        return value;
+    }
+}

package/@tool-box/utils/random/random.d.ts

@@ -0,0 +1,5 @@
+export declare class Random {
+    static number(min: number, max: number): number;
+    static enum<T extends Record<string, unknown>>(anEnum: T): T[keyof T];
+    static enumExcluding<T extends Record<string, unknown>>(anEnum: T, excepts: Array<T[keyof T]>): T[keyof T];
+}

package/@tool-box/utils/{randoms/random-value.js → random/random.js}

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RandomValue = void 0;
-class RandomValue {
-    static randomNumber(min, max) {
+export class Random {
+    static number(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    static randomEnumValue(anEnum) {
+    static enum(anEnum) {
         const keys = Object.keys(anEnum).filter((x) => Number.isNaN(Number(x)));
         const randomKeyIndex = Math.floor(Math.random() * keys.length);
         const randomKey = keys[randomKeyIndex];
         return anEnum[randomKey];
     }
-    static randomEnumValueExcept(anEnum, excepts) {
+    static enumExcluding(anEnum, excepts) {
         const exceptKeys = excepts.map((value) => Object.keys(anEnum).find((key) => anEnum[key] === value));
         const validKeys = Object.keys(anEnum).filter((key) => Number.isNaN(Number(key)) && !exceptKeys.includes(key));
         if (validKeys.length === 0) {
@@ -22,4 +19,3 @@ class RandomValue {
         return anEnum[randomKey];
     }
 }
-exports.RandomValue = RandomValue;

package/@tool-box/utils/type-guard/guardian-exception.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuardianException = void 0;
-class GuardianException extends Error {
+export class GuardianException extends Error {
 }
-exports.GuardianException = GuardianException;

package/@tool-box/utils/type-guard/guardian.d.ts

@@ -1,31 +1,29 @@
 import { PrimitiveType } from "./guardian.type";
-export declare class Guardian {
+declare class Guardian {
     static and(...args: boolean[]): boolean;
     static or(...args: boolean[]): boolean;
     static greaterThan(value: number, reference: number): boolean;
     static lessThan(value: number, reference: number): boolean;
-    static isArrayEmpty<T>(value: T[] | null | undefined): value is T[];
-    static isArrayNotEmpty<T>(value: T[] | null | undefined): value is T[];
-    static isEmpty<T>(value: unknown): value is null | undefined | T[];
-    static isNotEmpty(value: unknown): boolean;
+    static isEmptyArray<T>(value: T[] | null | undefined): value is T[];
+    static isFilledArray<T>(value: T[] | null | undefined): value is T[];
+    static isLengthArray<T>(value: T[] | null | undefined, reference: number): value is T[];
+    private static isEmpty;
     static isUndefined(value: unknown): value is undefined;
     static isNotUndefined(value: unknown): value is boolean;
     static isNull(value: unknown): value is null;
     static isNotNull(value: unknown): value is boolean;
     static isEqual(valueA: unknown, valueB: unknown): boolean;
-    static isAnyOf(reference: unknown, anyValues: unknown[]): boolean;
     static isDifferent(valueA: unknown, valueB: unknown): boolean;
-    static isTruthy(value: boolean): boolean;
-    static isFalsy(value: boolean | undefined): boolean;
+    static isAnyOf(reference: unknown, anyValues: unknown[]): boolean;
     static ternaryCondition<TTrue, TFalse>(condition: boolean, returnIfTrue: TTrue, returnIfFalse: TFalse): TTrue | TFalse;
     static isBetween(value: number | string, min: number, max: number): boolean;
-    static isLengthEqual(value: unknown, length: number): boolean;
     static isNullOrUndefined(value: unknown): value is null | undefined;
     static isNotNullOrUndefined(value: unknown): value is boolean;
-    static isNumber(value: unknown): value is number;
-    static isString(value: unknown): value is string;
-    static isArray(value: unknown): value is unknown[];
-    static isObject(value: unknown): value is object;
+    private static isNumber;
+    private static isString;
+    private static isArray;
+    private static isObject;
     static isTypeOf<T>(value: unknown, type: PrimitiveType): value is T;
     static isNotTypeOf<T>(value: unknown, type: PrimitiveType): value is T;
 }
+export { Guardian as _ };