@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.10

package/docs/API/10-lang/10-dataStructure/10-createErrorInterpreter.ts

@@ -0,0 +1,74 @@
+/**
+ * @title DDataStructure.createErrorInterpreter
+ *
+ * Transformer les issues d’une erreur de validation ou de codec en messages interprétables.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+
+const userStructure = DDataStructure.object({
+	email: DDataStructure.string([DDataStructure.email()]),
+	age: DDataStructure.number([DDataStructure.greaterThanOrEqual(18)]),
+});
+
+const checkResult = userStructure.check({
+	email: "invalid-email",
+	age: 12,
+});
+
+// Une erreur conserve les sources techniques de chaque issue : structure,
+// type, contrainte ou codec.
+const error = DCommon.pipe(
+	checkResult,
+	DEither.unwrapByInformationOrThrow("check-error"),
+);
+
+type _CheckError = DCommon.ExpectType<
+	typeof error,
+	DDataStructure.Error,
+	"strict"
+>;
+
+// Les dictionnaires par défaut produisent des messages génériques pour les
+// structures, types, contraintes et codecs fournis par DuploJS.
+const dataStructureDictionary = {
+	...DDataStructure.defaultErrorInterpreterDataStructureDictionary,
+	"@DuplojsLangDataStructure/email-constraint": (source, issue) => {
+		type _CheckSource = DCommon.ExpectType<
+			typeof source,
+			DDataStructure.EmailConstraint,
+			"strict"
+		>;
+		type _CheckIssue = DCommon.ExpectType<
+			typeof issue,
+			DDataStructure.Issue,
+			"strict"
+		>;
+
+		return `Invalid email at ${issue.path}: ${source.definition.message}`;
+	},
+	"@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source) => (
+		`Expected a value greater than or equal to ${source.definition.threshold}.`
+	),
+} satisfies DDataStructure.StructureDictionaryParams;
+
+const interpretError = DDataStructure.createErrorInterpreter(
+	dataStructureDictionary,
+	DDataStructure.defaultErrorInterpreterCodecDictionary,
+);
+
+// L’interpréteur renvoie une issue enrichie, sans perdre la donnée, le chemin
+// ni la source de l’erreur d’origine.
+const interpretedIssues = interpretError(error);
+
+type _CheckInterpretedIssues = DCommon.ExpectType<
+	typeof interpretedIssues,
+	readonly DDataStructure.InterpretedIssues[],
+	"strict"
+>;
+
+// Les dictionnaires peuvent être omis lorsque l’application veut seulement
+// enrichir les issues avec leurs champs `interpretedMessage` optionnels.
+const interpretWithoutDictionaries = DDataStructure.createErrorInterpreter();
+const uninterpretedIssues = interpretWithoutDictionaries(error);

package/docs/API/10-lang/10-dataStructure/10-date.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DDataStructure.date
+ *
+ * Construire une structure représentant les dates DuploJS.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DChrono from "@duplojs/lang/chrono";
+
+const structure = DDataStructure.date();
+const result = structure.check(new Date("2024-01-01T00:00:00.000Z"));
+
+// La structure représente le type indiqué par son contrat.
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.TypeStructure<DChrono.TheDate, readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	DChrono.TheDate,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-email.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.email
+ *
+ * Construire une contrainte d’adresse email et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DString from "@duplojs/lang/string";
+
+const emailConstraint = DDataStructure.email();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof emailConstraint,
+	DDataStructure.EmailConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.string([emailConstraint]);
+const result = structure.check("jane@example.com");
+
+// Après validation, la valeur représente une chaîne portant la garantie Email.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string & DString.Email,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-endsWith.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DDataStructure.endsWith
+ *
+ * Construire une contrainte de suffixe et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.endsWith(".json");
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.EndsWithConstraint<".json">,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("settings.json");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	`${string}.json`,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-even.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.even
+ *
+ * Construire une contrainte de nombre pair et l’appliquer à une structure numérique.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.even();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.EvenConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(8);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.Even,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-extend.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DDataStructure.extend
+ *
+ * Étendre une structure objet en ajoutant ou en remplaçant des propriétés.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const source = DDataStructure.object({
+	name: DDataStructure.string(),
+});
+const structure = DDataStructure.extend(source, {
+	id: DDataStructure.number(),
+});
+const result = structure.check({
+	name: "Jane",
+	id: 1,
+});
+
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	{
+		readonly name: string;
+		readonly id: number;
+	},
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-greaterThan.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.greaterThan
+ *
+ * Construire une contrainte de nombre supérieur à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.greaterThan(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.GreaterThanConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(4);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThan<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-greaterThanOrEqual.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.greaterThanOrEqual
+ *
+ * Construire une contrainte de nombre supérieur ou égal à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.greaterThanOrEqual(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.GreaterThanOrEqualConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(3);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThanOrEqual<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-include.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DDataStructure.include
+ *
+ * Construire une contrainte d’inclusion et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.include("lang");
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.IncludeConstraint<"lang">,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("duplo-lang");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	`${string}lang${string}`,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-integer.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.integer
+ *
+ * Construire une contrainte de nombre entier et l’appliquer à une structure numérique.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.integer();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.IntegerConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(42);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.Integer,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-isNullStructure.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isNullStructure
+ *
+ * Vérifier qu’une structure représente exactement le type `null`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.null();
+const result = DDataStructure.isNullStructure(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-isNullable.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isNullable
+ *
+ * Vérifier qu’une structure accepte la valeur `null`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.nullable(DDataStructure.string());
+const result = DDataStructure.isNullable(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-isOptional.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isOptional
+ *
+ * Vérifier qu’une structure accepte la valeur `undefined`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.optional(DDataStructure.string());
+const result = DDataStructure.isOptional(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-isUndefinedStructure.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isUndefinedStructure
+ *
+ * Vérifier qu’une structure représente exactement le type `undefined`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.undefined();
+const result = DDataStructure.isUndefinedStructure(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-lazy.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DDataStructure.lazy
+ *
+ * Construire une structure dont la résolution est différée.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.lazy(
+	() => DDataStructure.string(),
+);
+const result = structure.check("DuploJS");
+
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.LazyStructure<string, readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-lessThan.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.lessThan
+ *
+ * Construire une contrainte de nombre inférieur à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.lessThan(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.LessThanConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(2);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.LessThan<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-lessThanOrEqual.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.lessThanOrEqual
+ *
+ * Construire une contrainte de nombre inférieur ou égal à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.lessThanOrEqual(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.LessThanOrEqualConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(3);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.LessThanOrEqual<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-literal.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DDataStructure.literal
+ *
+ * Construire une structure représentant une ou plusieurs valeurs littérales.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.literal([
+	"draft",
+	"published",
+]);
+const result = structure.check("published");
+
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	"draft" | "published",
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-maxCharacters.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.maxCharacters
+ *
+ * Construire une contrainte de longueur maximale pour une chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DString from "@duplojs/lang/string";
+
+const constraint = DDataStructure.maxCharacters(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.MaxCharactersConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("abc");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string & DString.MaxCharacters<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-maxElements.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.maxElements
+ *
+ * Construire une contrainte de cardinalité maximale pour un tableau.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.maxElements(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.MaxElementsConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.array(DDataStructure.number(), [constraint]);
+const result = structure.check([1, 2]);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	readonly number[] & DArray.MaxElements<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-minCharacters.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.minCharacters
+ *
+ * Construire une contrainte de longueur minimale pour une chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DString from "@duplojs/lang/string";
+
+const constraint = DDataStructure.minCharacters(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.MinCharactersConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("abc");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string & DString.MinCharacters<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-minElements.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.minElements
+ *
+ * Construire une contrainte de cardinalité minimale pour un tableau.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.minElements(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.MinElementsConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.array(DDataStructure.number(), [constraint]);
+const result = structure.check([1, 2, 3]);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	readonly number[] & DArray.MinElements<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-multipleOf.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.multipleOf
+ *
+ * Construire une contrainte de multiple numérique.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.multipleOf(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.MultipleOfConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(6);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.MultipleOf<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-negative.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.negative
+ *
+ * Construire une contrainte de nombre négatif ou nul.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.negative();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.NegativeConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(-1);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.Negative,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-notEmpty.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.notEmpty
+ *
+ * Construire une contrainte qui refuse les chaînes vides.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DString from "@duplojs/lang/string";
+
+const constraint = DDataStructure.notEmpty();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.NotEmptyConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("DuploJS");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string & DString.NotEmpty,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-notZero.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.notZero
+ *
+ * Construire une contrainte qui refuse zéro.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.notZero();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.NotZeroConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(1);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.NotZero,
+	"strict"
+>;