xdbc 1.0.73

package/src/DBC/AE.ts

@@ -0,0 +1,247 @@
+import { DBC } from "../DBC.js";
+/**
+ * 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 class AE extends DBC {
+	// #region Condition checking.
+	/**
+	 * 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}. */
+	public static checkAlgorithm(
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		condition: { check: (toCheck: any) => boolean | string },
+		value: object,
+		index: number | undefined,
+		idxEnd: number | undefined,
+	): boolean | string {
+		if (Array.isArray(value)) {
+			if (index !== undefined && idxEnd === undefined) {
+				if (index > -1 && index < value.length) {
+					const result = condition.check(value[index]);
+
+					if (typeof result === "string") {
+						return `Violating-Arrayelement at index "${index}" with value "${value[index]}". ${result}`;
+					}
+				}
+
+				return true; // In order for optional parameter to not cause an error if they are omitted.
+			}
+
+			for (
+				let i = index;
+				i <
+				(idxEnd !== undefined
+					? idxEnd !== -1
+						? idxEnd + 1
+						: (value as []).length
+					: (value as []).length);
+				i++
+			) {
+				const result = condition.check(value[i]);
+
+				if (result !== true) {
+					return `Violating-Arrayelement at index ${i}. ${result}`;
+				}
+			}
+		} else {
+			return condition.check(value);
+		}
+
+		return true;
+	}
+	/**
+	 * 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 dbc				See {@link DBC.decPrecondition }.
+	 *
+	 * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of "realConditions" returns one.
+	 * 			Otherwise TRUE. */
+	public static PRE(
+		realConditions: // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| Array<{ check: (toCheck: any) => boolean | string }>
+			// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| { check: (toCheck: any) => boolean | string },
+		index: number | undefined = undefined,
+		idxEnd: number | undefined = undefined,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		methodName: string | symbol,
+		parameterIndex: number,
+	) => void {
+		return DBC.decPrecondition(
+			(
+				value: object,
+				target: object,
+				methodName: string,
+				parameterIndex: number,
+			) => {
+				if (Array.isArray(realConditions)) {
+					for (const currentCondition of realConditions) {
+						const result = AE.checkAlgorithm(
+							currentCondition,
+							value,
+							index,
+							idxEnd,
+						);
+
+						if (typeof result !== "boolean") return result;
+					}
+				} else {
+					return AE.checkAlgorithm(
+						// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+						realConditions as { check: (toCheck: any) => boolean | string },
+						value,
+						index,
+						idxEnd,
+					);
+				}
+
+				return true;
+			},
+			dbc,
+			path,
+		);
+	}
+	/**
+	 * 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 dbc				See {@link DBC.decPrecondition }.
+	 *
+	 * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of "realConditions" return one.
+	 * 			Otherwise TRUE. */
+	public static POST(
+		realConditions: // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| Array<{ check: (toCheck: any) => boolean | string }>
+			// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| { check: (toCheck: any) => boolean | string },
+		index: number | undefined = undefined,
+		idxEnd: number | undefined = undefined,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		propertyKey: string,
+		descriptor: PropertyDescriptor,
+	) => PropertyDescriptor {
+		return DBC.decPostcondition(
+			(value: object, target: object, propertyKey: string) => {
+				if (Array.isArray(realConditions)) {
+					for (const currentCondition of realConditions) {
+						const result = AE.checkAlgorithm(
+							currentCondition,
+							value,
+							index,
+							idxEnd,
+						);
+
+						if (typeof result !== "boolean") return result;
+					}
+				} else {
+					return AE.checkAlgorithm(
+						// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+						realConditions as { check: (toCheck: any) => boolean | string },
+						value,
+						index,
+						idxEnd,
+					);
+				}
+
+				return true;
+			},
+			dbc,
+			path,
+		);
+	}
+	// #endregion Condition checking.
+	// #region Referenced Condition checking.
+	//
+	// For usage in dynamic scenarios (like global functions).
+	//
+	/**
+	 * Invokes the {@link AE.checkAlgorithm } passing the value "toCheck", {@link AE.equivalent } and {@link EQ.invert }.
+	 *
+	 * @param toCheck See {@link EQ.checkAlgorithm }.
+	 *
+	 * @returns See {@link EQ.checkAlgorithm}. */
+	public check(
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		toCheck: any,
+	) {
+		if (Array.isArray(this.conditions)) {
+			for (const currentCondition of this.conditions) {
+				const result = AE.checkAlgorithm(
+					currentCondition,
+					toCheck,
+					this.index,
+					this.idxEnd,
+				);
+
+				if (typeof result !== "boolean") return result;
+			}
+		} else {
+			return AE.checkAlgorithm(
+				// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+				this.conditions as { check: (toCheck: any) => boolean | string },
+				toCheck,
+				this.index,
+				this.idxEnd,
+			);
+		}
+
+		return true;
+	}
+	/**
+	 * 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 }. */
+	public constructor(
+		protected conditions: // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| Array<{ check: (toCheck: any) => boolean | string }>
+			// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			| { check: (toCheck: any) => boolean | string },
+		protected index: number | undefined = undefined,
+		protected idxEnd: number | undefined = undefined,
+	) {
+		super();
+	}
+	// #endregion Referenced Condition checking.
+}

package/src/DBC/EQ.ts

@@ -0,0 +1,121 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class EQ extends DBC {
+	// #region Condition checking.
+	/**
+	 * 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. */
+	public static checkAlgorithm(
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		toCheck: any,
+		equivalent: object,
+		invert,
+	): boolean | string {
+		if (!invert && equivalent !== toCheck) {
+			return `Value has to to be equal to "${equivalent}"`;
+		}
+
+		if (invert && equivalent === toCheck) {
+			return `Value must not to be equal to "${equivalent}"`;
+		}
+
+		return true;
+	}
+	/**
+	 * 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 }. */
+	public static PRE(
+		// biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+		equivalent: any,
+		invert = false,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		methodName: string | symbol,
+		parameterIndex: number,
+	) => void {
+		return DBC.decPrecondition(
+			(
+				value: object,
+				target: object,
+				methodName: string,
+				parameterIndex: number,
+			) => {
+				return EQ.checkAlgorithm(value, equivalent, invert);
+			},
+			dbc,
+			path,
+		);
+	}
+	/**
+	 * 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 }. */
+	public static POST(
+		// biome-ignore lint/suspicious/noExplicitAny: To check for UNDEFINED and NULL.
+		equivalent: any,
+		invert = false,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		propertyKey: string,
+		descriptor: PropertyDescriptor,
+	) => PropertyDescriptor {
+		return DBC.decPostcondition(
+			(value: object, target: object, propertyKey: string) => {
+				return EQ.checkAlgorithm(value, equivalent, invert);
+			},
+			dbc,
+			path,
+		);
+	}
+	// #endregion Condition checking.
+	// #region Referenced Condition checking.
+	//
+	// For usage in dynamic scenarios (like with AE-DBC).
+	//
+	/**
+	 * 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}. */
+	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+	public check(toCheck: any) {
+		return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);
+	}
+	/**
+	 * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.
+	 *
+	 * @param equivalent See {@link EQ.check }. */
+	public constructor(
+		// biome-ignore lint/suspicious/noExplicitAny: To be able to match UNDEFINED and NULL.
+		protected equivalent: any,
+		protected invert = false,
+	) {
+		super();
+	}
+	// #endregion Referenced Condition checking.
+}

package/src/DBC/INSTANCE.ts

@@ -0,0 +1,107 @@
+import { DBC } from "../DBC.js";
+/**
+ * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.
+ *
+ * @remarks
+ * Author: 		Salvatore Callari (Callari@WaXCode.net) / 2025
+ * Maintainer:	Salvatore Callari (XDBC@WaXCode.net) */
+export class INSTANCE extends DBC {
+	/**
+	 * Checks if the value "toCheck" is complies to the {@link RegExp } "expression".
+	 *
+	 * @param toCheck	The value that has comply to the {@link RegExp } "expression" for this {@link DBC } to be fulfilled.
+	 * @param reference		The {@link RegExp } the one "toCheck" has comply to in order for this {@link DBC } to be
+	 * 						fulfilled.
+	 *
+	 * @returns TRUE if the value "toCheck" is of the specified "type", otherwise FALSE. */
+	// biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+	public static checkAlgorithm(toCheck: any, reference: any): boolean | string {
+		if (!(toCheck instanceof reference)) {
+			return `Value has to be an instance of "${reference}" but is of type "${typeof toCheck}"`;
+		}
+
+		return true;
+	}
+	/**
+	 * 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 }. */
+	public static PRE(
+		// biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+		reference: any,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		methodName: string | symbol,
+		parameterIndex: number,
+	) => void {
+		return DBC.decPrecondition(
+			(
+				value: object,
+				target: object,
+				methodName: string,
+				parameterIndex: number,
+			) => {
+				return INSTANCE.checkAlgorithm(value, reference);
+			},
+			dbc,
+			path,
+		);
+	}
+	/**
+	 * 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 }. */
+	public static POST(
+		// biome-ignore lint/suspicious/noExplicitAny: In order to perform an "instanceof" check.
+		reference: any,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		propertyKey: string,
+		descriptor: PropertyDescriptor,
+	) => PropertyDescriptor {
+		return DBC.decPostcondition(
+			(value: object, target: object, propertyKey: string) => {
+				return INSTANCE.checkAlgorithm(value, reference);
+			},
+			dbc,
+			path,
+		);
+	}
+	// #endregion Condition checking.
+	// #region Referenced Condition checking.
+	//
+	// For usage in dynamic scenarios (like with AE-DBC).
+	//
+	/**
+	 * 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}. */
+	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+	public check(toCheck: any) {
+		return INSTANCE.checkAlgorithm(toCheck, this.reference);
+	}
+	/**
+	 * Creates this {@link INSTANCE } by setting the protected property {@link INSTANCE.reference } used by {@link INSTANCE.check }.
+	 *
+	 * @param reference See {@link INSTANCE.check }. */
+	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+	public constructor(protected reference: any) {
+		super();
+	}
+}

package/src/DBC/JSON.OP.ts

@@ -0,0 +1,179 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } demanding that an {@link object } has specific properties of specific types.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class JSON_OP extends DBC {
+	// #region Condition checking.
+	/**
+	 * Checks if the object "toCheck" has the "necessaryProperties" of necessary type.
+	 *
+	 * @param toCheck				The {@link object } to check for the necessary properties.
+	 * @param necessaryProperties	The { name : string, type : string }s defining the properties and type the {@link object } to
+	 * 								check needs to have.
+	 * @param checkElements			Indicates if "toCheck" is an iterable object of which all elements have to be checked.
+	 * 								Elements will only be checked if "toCheck" is iterable, otherwise "toCheck" itself
+	 * 								will be checked.
+	 *
+	 * @returns TRUE if the value "toCheck" or it's elements, if "checkElements is TRUE, has all "necessaryProperties", otherwise a {@link string } to report the infringement. */
+	public static checkAlgorithm(
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		toCheck: any,
+		necessaryProperties: Array<{ name: string; type: string }>,
+		checkElements,
+	): boolean | string {
+		if (toCheck === undefined || null) {
+			return `[ UNDEFINED or NULL received instead of object with following properties: ${JSON.stringify(necessaryProperties)} ]`;
+		}
+
+		for (const property of necessaryProperties)
+			if (checkElements && typeof toCheck[Symbol.iterator] === "function") {
+				for (const element of toCheck) {
+					if (
+						// biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+						!element.hasOwnProperty(property.name) ||
+						// biome-ignore lint/suspicious/useValidTypeof: <explanation>
+						typeof element[property.name] !== property.type
+					) {
+						return `[ Object "${JSON.stringify(element)}" in Array "${JSON.stringify(toCheck)}" does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+					}
+				}
+			} else {
+				if (
+					// biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+					!toCheck.hasOwnProperty(property.name) ||
+					// biome-ignore lint/suspicious/useValidTypeof: <explanation>
+					typeof toCheck[property.name] !== property.type
+				) {
+					return `[ Object does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+				}
+			}
+
+		return true;
+	}
+	/**
+	 * A parameter-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+	 * by the tagged parameter.
+	 *
+	 * @param expression	See {@link JSON.checkAlgorithm }.
+	 * @param path			See {@link DBC.decPrecondition }.
+	 * @param dbc			See {@link DBC.decPrecondition }.
+	 *
+	 * @returns See {@link DBC.decPrecondition }. */
+	public static PRE(
+		necessaryProperties: Array<{ name: string; type: string }>,
+		checkElements = false,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		methodName: string | symbol,
+		parameterIndex: number,
+	) => void {
+		return DBC.decPrecondition(
+			(
+				value: string,
+				target: object,
+				methodName: string,
+				parameterIndex: number,
+			) => {
+				return JSON_OP.checkAlgorithm(
+					value,
+					necessaryProperties,
+					checkElements,
+				);
+			},
+			dbc,
+			path,
+		);
+	}
+	/**
+	 * A method-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+	 * by the tagged method's returnvalue.
+	 *
+	 * @param expression	See {@link JSON.checkAlgorithm }.
+	 * @param path			See {@link DBC.Postcondition }.
+	 * @param dbc			See {@link DBC.decPostcondition }.
+	 *
+	 * @returns See {@link DBC.decPostcondition }. */
+	public static POST(
+		necessaryProperties: Array<{ name: string; type: string }>,
+		checkElements = false,
+		path: string | undefined = undefined,
+		dbc = "WaXCode.DBC",
+	): (
+		target: object,
+		propertyKey: string,
+		descriptor: PropertyDescriptor,
+	) => PropertyDescriptor {
+		return DBC.decPostcondition(
+			// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+			(value: any, target: object, propertyKey: string) => {
+				return JSON_OP.checkAlgorithm(
+					value,
+					necessaryProperties,
+					checkElements,
+				);
+			},
+			dbc,
+			path,
+		);
+	}
+	// #endregion Condition checking.
+	// #region Referenced Condition checking.
+	//
+	// For usage in dynamic scenarios (like with AE-DBC).
+	//
+	/**
+	 * Invokes the {@link JSON_OP.checkAlgorithm } passing the value "toCheck", {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+	 *
+	 * @param toCheck See {@link JSON_OP.checkAlgorithm }.
+	 *
+	 * @returns See {@link JSON_OP.checkAlgorithm}. */
+	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+	public check(toCheck: any) {
+		return JSON_OP.checkAlgorithm(
+			toCheck,
+			this.necessaryProperties,
+			this.checkElements,
+		);
+	}
+	/**
+	 * Creates this {@link JSON_OP } by setting the protected property {@link JSON_OP.necessaryProperties } and {@link checkElements } used by {@link JSON_OP.check }.
+	 *
+	 * @param necessaryProperties	See {@link JSON_OP.check }.
+	 * @param checkElements 		See {@link JSON_OP.check }. */
+	public constructor(
+		public necessaryProperties: Array<{ name: string; type: string }>,
+		public checkElements = false,
+	) {
+		super();
+	}
+	// #endregion Referenced Condition checking.
+	// #region In-Method checking.
+	/**
+	 * Invokes the {@link JSON_OP.checkAlgorithm } passing the value "toCheck", {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+	 *
+	 * @param toCheck				See {@link JSON_OP.checkAlgorithm} }.
+	 * @param necessaryProperties	See {@link JSON_OP.checkAlgorithm} }.
+	 * @param checkElements			See {@link JSON_OP.checkAlgorithm} }.
+	 */
+	public static check(
+		// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+		toCheck: any,
+		necessaryProperties: Array<{ name: string; type: string }>,
+		checkElements = false,
+	) {
+		const checkResult = JSON_OP.checkAlgorithm(
+			toCheck,
+			necessaryProperties,
+			checkElements,
+		);
+
+		if (typeof checkResult === "string") {
+			throw new DBC.Infringement(checkResult);
+		}
+	}
+	// #endregion In-Method checking.
+}