xdbc 1.0.212 → 1.0.213

package/dist/DBC/AE.d.ts

@@ -0,0 +1,117 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that all elements of an {@link object }s have to fulfill
+ * a given {@link object }'s check-method (**( toCheck : any ) => boolean | string**).
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export declare class AE extends DBC {
+    protected conditions: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    };
+    protected index: number | undefined;
+    protected idxEnd: number | undefined;
+    /**
+     * Checks each element of the **value**-{@link Array < any >} against the given **condition**, if it is one. If it is not
+     * the **value** itself will be checked.
+     *
+     * @param condition	The { check: (toCheck: any) => boolean | string } to check the **value** against.
+     * @param value		Either **value**-{@link Array < any >}, which's elements will be checked, or the value to be
+     * 					checked itself.
+     * @param index		If specified with **idxEnd** being undefined, this {@link Number } will be seen as the index of
+     * 					the value-{@link Array }'s element to check. If value isn't an {@link Array } this parameter
+     * 					will not have any effect.
+     * 					With **idxEnd** not undefined this parameter indicates the beginning of the span of elements to
+     * 					check within the value-{@link Array }.
+     * @param idxEnd	Indicates the last element's index (including) of the span of value-{@link Array } elements to check.
+     * 					Setting this parameter to -1 specifies that all value-{@link Array }'s elements beginning from the
+     * 					specified **index** shall be checked.
+     *
+     * @returns As soon as the **condition** returns a {@link string }, instead of TRUE, the returned string. TRUE if the
+     * 			**condition** never returns a {@link string}. */
+    static checkAlgorithm(condition: {
+        check: (toCheck: unknown | null | undefined) => boolean | string;
+    }, value: object, index: number | undefined, idxEnd: number | undefined): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged parameter-value against with.
+     * When specifying an **index** and the tagged parameter's **value** is an {@link Array }, the **realConditions** apply to the
+     * element at the specified **index**.
+     * If the {@link Array } is too short the currently processed { check: (toCheck: any) => boolean | string } of
+     * **realConditions** will be verified to TRUE automatically, considering optional parameters.
+     * If an **index** is specified but the tagged parameter's value isn't an array, the **index** is treated as being undefined.
+     * If **index** is undefined and the tagged parameter's value is an {@link Array } each element of it will be checked
+     * against the **realConditions**.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param hint				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of **realConditions** returns one.
+     * 			Otherwise TRUE. */
+    static PRE(realConditions: Array<{
+        check: (toCheck: unknown | undefined | null) => boolean | string;
+    }> | {
+        check: (toCheck: unknown | undefined | null) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged method's return-value against with.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param hint				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of **realConditions** return one.
+     * 			Otherwise TRUE. */
+    static POST(realConditions: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link AE.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged field.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decInvariant }.
+     * @param hint				See {@link DBC.decInvariant }.
+     * @param dbc				See {@link DBC.decInvariant }.
+     *
+     * @returns	See {@link DBC.decInvariant }. */
+    static INVARIANT(realConditions: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link AE.checkAlgorithm } with all {@link AE.conditions } and the {@link object } {@link toCheck },
+     * {@link AE.index } & {@link AE.idxEnd }.
+     *
+     * @param toCheck See {@link AE.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Creates this {@link AE } by setting the protected property {@link AE.conditions }, {@link AE.index } and {@link AE.idxEnd } used by {@link AE.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(conditions: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined);
+}

package/dist/DBC/COMPARISON/GREATER.d.ts

@@ -0,0 +1,13 @@
+import { COMPARISON } from "../COMPARISON";
+/** See {@link COMPARISON }. */
+export declare class GREATER extends COMPARISON {
+    equivalent: any;
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link COMPARISON.POST }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link COMPARISON.constructor }. */
+    constructor(equivalent: any);
+}

package/dist/DBC/COMPARISON/GREATER_OR_EQUAL.d.ts

@@ -0,0 +1,13 @@
+import { COMPARISON } from "../COMPARISON";
+/** See {@link COMPARISON }. */
+export declare class GREATER_OR_EQUAL extends COMPARISON {
+    equivalent: any;
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link COMPARISON.POST }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link COMPARISON.constructor }. */
+    constructor(equivalent: any);
+}

package/dist/DBC/COMPARISON/LESS.d.ts

@@ -0,0 +1,13 @@
+import { COMPARISON } from "../COMPARISON";
+/** See {@link COMPARISON }. */
+export declare class LESS extends COMPARISON {
+    equivalent: any;
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link COMPARISON.POST }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link COMPARISON.constructor }. */
+    constructor(equivalent: any);
+}

package/dist/DBC/COMPARISON/LESS_OR_EQUAL.d.ts

@@ -0,0 +1,13 @@
+import { COMPARISON } from "../COMPARISON";
+/** See {@link COMPARISON }. */
+export declare class LESS_OR_EQUAL extends COMPARISON {
+    equivalent: any;
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link COMPARISON.POST }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link COMPARISON.constructor }. */
+    constructor(equivalent: any);
+}

package/dist/DBC/COMPARISON.d.ts

@@ -0,0 +1,70 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining a comparison between two {@link object }s.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export declare class COMPARISON extends DBC {
+    equivalent: any;
+    equalityPermitted: boolean;
+    invert: boolean;
+    /**
+     * Does a comparison between the {@link object } **toCheck** and the **equivalent**.
+     *
+     * @param toCheck		The value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.
+     * @param equivalent	The {@link object } the one **toCheck** has to be equal to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(toCheck: any, equivalent: any, equalityPermitted: boolean, invert: boolean): string | true;
+    /**
+     * A parameter-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.decPrecondition }.
+     * @param hint				See {@link DBC.decPrecondition }.
+     * @param dbc			    See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.Postcondition }.
+     * @param hint				See {@link DBC.decPostcondition }.
+     * @param dbc			    See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link COMPARISON.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	    See {@link COMPARISON.checkAlgorithm }.
+     * @param equalityPermitted See {@link COMPARISON.checkAlgorithm }.
+     * @param path			    See {@link DBC.decInvariant }.
+     * @param hint				See {@link DBC.decInvariant }.
+     * @param dbc			    See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link COMPARISON.checkAlgorithm } passing the value **toCheck**, {@link COMPARISON.equivalent } and {@link COMPARISON.invert }.
+     *
+     * @param toCheck See {@link COMPARISON.checkAlgorithm }.
+     *
+     * @returns See {@link COMPARISON.checkAlgorithm}. */
+    check(toCheck: any): string | true;
+    /**
+     * Creates this {@link COMPARISON } by setting the protected property {@link COMPARISON.equivalent }, {@link COMPARISON.equalityPermitted } and {@link COMPARISON.invert } used by {@link COMPARISON.check }.
+     *
+     * @param equivalent        See {@link COMPARISON.check }.
+     * @param equalityPermitted See {@link COMPARISON.check }.
+     * @param invert            See {@link COMPARISON.check }. */
+    constructor(equivalent: any, equalityPermitted?: boolean, invert?: boolean);
+}

package/dist/DBC/DEFINED.d.ts

@@ -0,0 +1,62 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that an {@link object }s must be defined thus it's value may not be **null** or **undefined**.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+export declare class DEFINED extends DBC {
+    /**
+     * Checks if the value **toCheck** is null or undefined.
+     *
+     * @param toCheck	The {@link Object } to check.
+     *
+     * @returns TRUE if the value **toCheck** is of the specified **type**, otherwise FALSE. */
+    static checkAlgorithm(toCheck: any): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param type	See {@link DEFINED.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param type	See {@link DEFINED.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(type: string, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link DEFINED.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param type	See {@link DEFINED.checkAlgorithm }.
+     * @param path	See {@link DBC.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(type: string, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
+     *
+     * @param toCheck See {@link DEFINED.checkAlgorithm }.
+     *
+     * @returns See {@link DEFINED.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Invokes the {@link DEFINED.checkAlgorithm } passing the value **toCheck** and the {@link DEFINED.type } .
+     *
+     * @param toCheck	See {@link DEFINED.checkAlgorithm }.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link DEFINED }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }.*/
+    static tsCheck<CANDIDATE = unknown>(toCheck: CANDIDATE | undefined | null, hint?: string | undefined, id?: string | undefined): CANDIDATE;
+}

package/dist/DBC/EQ/DIFFERENT.d.ts

@@ -0,0 +1,26 @@
+import { EQ } from "../EQ";
+/**
+ * DIFFERENT class for inequality comparisons.
+ *
+ * This class extends EQ and provides methods to check if a value is different (not equal)
+ * from a specified equivalent value. It inverts the equality check by always passing
+ * `true` for the invert parameter to the parent EQ class methods.
+ *
+ * @remarks
+ * The class provides precondition (PRE), postcondition (POST), and invariant (INVARIANT)
+ * checks for Design by Contract programming patterns.
+ *
+ * @see {@link COMPARISON}
+ * @see {@link EQ}
+ */
+export declare class DIFFERENT extends EQ {
+    equivalent: any;
+    /** See {@link EQ.PRE }. Always inverts equality check. */
+    static PRE(equivalent: any, _invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link EQ.POST }. Always inverts equality check. */
+    static POST(equivalent: any, _invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link EQ.INVARIANT }. Always inverts equality check. */
+    static INVARIANT(equivalent: any, _invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link EQ.constructor }. */
+    constructor(equivalent: any);
+}

package/dist/DBC/EQ.d.ts

@@ -0,0 +1,70 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export declare class EQ extends DBC {
+    protected equivalent: any;
+    protected invert: boolean;
+    /**
+     * Checks if the value **toCheck** is equal to the specified **equivalent**.
+     *
+     * @param toCheck		The value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.
+     * @param equivalent	The {@link object } the one **toCheck** has to be equal to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(toCheck: any, equivalent: object, invert: boolean): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(equivalent: any, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(equivalent: any, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(equivalent: any, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck**, {@link EQ.equivalent } and {@link EQ.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck** and the specified **type** .
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link EQ }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link EQ }.*/
+    static tsCheck<CANDIDATE>(toCheck: CANDIDATE | undefined | null, equivalent: any, hint?: string | undefined, id?: string | undefined): CANDIDATE;
+    /**
+     * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(equivalent: any, invert?: boolean);
+}

package/dist/DBC/HasAttribute.d.ts

@@ -0,0 +1,72 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that a {@link HTMLElement } gotta have a certain attribute set.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export declare class HasAttribute extends DBC {
+    protected toCheckFor: string;
+    protected invert: boolean;
+    /**
+     * Checks if the {@link HTMLElement } **toCheck** has the attribute **toCheckFor**.
+     *
+     * @param toCheckFor  name of the attribute to check for whether it is set or not.
+     *
+     * @returns TRUE if the {@link HTMLElement } **toCheck** has set the attribute **toCheckFor**,
+     * 			otherwise a proper errormessage. */
+    static checkAlgorithm(toCheck: any, toCheckFor: string, invert: any): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link HasAttribute.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param toCheckFor	See {@link HasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(toCheckFor: string, invert?: boolean, path?: string | undefined, dbc?: string): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link HasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged method's returnvalue.
+     *
+     * @param toCheckFor	See {@link HasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(toCheckFor: string, invert?: boolean, path?: string | undefined, dbc?: string): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link hasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged field.
+     *
+     * @param toCheckFor	See {@link hasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(toCheckFor: any, invert?: boolean, path?: string | undefined, dbc?: string): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * A field-decorator factory using the {@link hasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged field's class instance.
+     *
+     * @param toCheckFor	See {@link hasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static cINVARIANT(toCheckFor: any, invert?: boolean, path?: string | undefined, dbc?: string): (target: unknown, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+    /**
+     * Invokes the {@link hasAttribute.checkAlgorithm } passing the value **toCheck**, {@link hasAttribute.equivalent } and
+     * {@link hasAttribute.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Creates this {@link DBC } by setting the protected property {@link hasAttribute.equivalent } used by
+     * {@link hasAttribute.check }.
+     *
+     * @param toCheckFor See {@link hasAttribute.check }. */
+    constructor(toCheckFor: string, invert?: boolean);
+}

package/dist/DBC/IF.d.ts

@@ -0,0 +1,90 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that an {@link object } has also to comply to a certain {@link DBC } if it complies to
+ * another specified one.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export declare class IF extends DBC {
+    protected condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    };
+    protected inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    };
+    protected invert: boolean;
+    /**
+     * Checks if the value **toCheck** complies to the specified **condition** and if so does also comply to the one **inCase**.
+     *
+     * @param toCheck	The value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.
+     * @param condition	The contract **toCheck** has to comply to in order to also have to comply to the one **inCase**.
+     * @param inCase	The contract **toCheck** has to also comply to if it complies to **condition**.
+     *
+     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(toCheck: any, condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, invert?: boolean): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path		See {@link DBC.decPrecondition }.
+     * @param dbc		See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, path?: string | undefined, invert?: boolean, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link IF.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path		See {@link DBC.Postcondition }.
+     * @param dbc		See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, path?: string | undefined, invert?: boolean, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link IF.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, path?: string | undefined, invert?: boolean, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link IF.checkAlgorithm } passing the value **toCheck**, {@link IF.equivalent } and {@link IF.invert }.
+     *
+     * @param toCheck See {@link IF.checkAlgorithm }.
+     *
+     * @returns See {@link IF.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Creates this {@link IF } by setting the protected property {@link IF.equivalent } used by {@link IF.check }.
+     *
+     * @param equivalent See {@link IF.check }. */
+    constructor(condition: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, inCase: {
+        check: (toCheck: unknown | undefined | null | object) => boolean | string;
+    }, invert?: boolean);
+}

package/dist/DBC/INSTANCE.d.ts

@@ -0,0 +1,84 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+export declare class INSTANCE extends DBC {
+    protected reference: any;
+    /**
+     * Checks if the value **toCheck** is an instance of the specified **reference**.
+     *
+     * @param toCheck	The value that has to be an instance of the **reference** in order for this {@link DBC }
+     * 					to be fulfilled.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     *
+     * @returns TRUE if the value **toCheck** is is an instance of the *reference**, **undefined** or **null**, otherwise FALSE. */
+    static checkAlgorithm(toCheck: any, ...references: any[]): boolean | string;
+    /**
+     * A parameter-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(reference: any | any[], path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * A method-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(reference: any | any[], path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * A field-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(reference: any | any[], path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck See {@link INSTANCE.checkAlgorithm }.
+     *
+     * @returns See {@link INSTANCE.checkAlgorithm}. */
+    check(toCheck: any): string | boolean;
+    /**
+     * Type-safe check that validates if a value is an instance of a specified reference.
+     *
+     * @param toCheck 	The value to check for instance validity.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** if it fulfills this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link INSTANCE }. */
+    static tsCheck<CANDIDATE = unknown>(toCheck: any, reference: any, hint?: string, id?: string | undefined): CANDIDATE;
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck 	See {@link INSTANCE.checkAlgorithm }.
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */
+    static tsCheckMulti<CANDIDATE = unknown>(toCheck: any, references: any[], hint?: string, id?: string | undefined): CANDIDATE;
+    /**
+     * Creates this {@link INSTANCE } by setting the protected property {@link INSTANCE.reference } used by {@link INSTANCE.check }.
+     *
+     * @param reference See {@link INSTANCE.check }. */
+    constructor(reference: any);
+}