@duplojs/agents-kit 0.1.0-beta.3 → 0.1.0-beta.6

package/docs/concepts/01-fundamental/02-currying/30-async-pipe.ts

@@ -10,7 +10,6 @@ import * as DString from "@duplojs/lang/string";
 // `asyncPipe` applique le même principe lorsqu'une ou plusieurs étapes
 // du traitement sont asynchrones.
 //
-// Promise<readonly Lowercase<string>[] & DArray.LengthEqual<2> & DArray.MinElements<2> & DArray.MaxElements<2>>
 const asyncTags = DCommon.asyncPipe(
 	Promise.resolve(" TypeScript, DuploJS " as const),
 	DString.split(","),
@@ -18,11 +17,15 @@ const asyncTags = DCommon.asyncPipe(
 	(tags) => Promise.resolve(tags),
 	DArray.map(DString.toLowerCase),
 );
+type _CheckAsyncTags = DCommon.ExpectType<
+	typeof asyncTags,
+	Promise<readonly Lowercase<string>[] & DArray.LengthEqual<2> & DArray.MinElements<2> & DArray.MaxElements<2>>,
+	"strict"
+>;
 
 // `asyncInnerPipe` permet de composer plusieurs transformations synchrones
 // ou asynchrones lorsqu'une callback asynchrone est attendue.
 //
-// Promise<readonly Promise<Lowercase<string>>[] & DArray.LengthEqual<2>>
 // map produit ici un tableau de promesses ; asyncPipe attend chaque étape, pas chaque élément.
 const values = DCommon.asyncPipe(
 	[" TypeScript ", " DuploJS "] as const,
@@ -34,9 +37,15 @@ const values = DCommon.asyncPipe(
 		),
 	),
 );
+type _CheckValues = DCommon.ExpectType<
+	typeof values,
+	Promise<readonly Promise<Lowercase<string>>[] & DArray.LengthEqual<2>>,
+	"strict"
+>;
 
 // Pour récupérer les valeurs résolues, ajouter une étape qui attend toutes les promesses.
 const resolvedValues = DCommon.asyncPipe(
 	values,
 	DCommon.promiseAll,
 );
+type _CheckResolvedValues = DCommon.ExpectType<typeof resolvedValues, Promise<Lowercase<string>[]>, "strict">;

package/docs/concepts/01-fundamental/03-either/10-discrimination.ts

@@ -15,20 +15,22 @@ declare const myResult: (
 
 // Choisir Right ou Left lorsque seul le statut du résultat compte.
 // whenIsRight transforme la valeur contenue dans un Right et transmet les Left tels quels.
-// "result" | DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>
 const resultWhenIsRight = DCommon.pipe(
 	myResult,
 	DEither.whenIsRight(
 		(rightValue) => rightValue,
 	),
 );
-// void | DEither.Success<"result"> | Error
+type _CheckResultWhenIsRight = DCommon.ExpectType<
+	typeof resultWhenIsRight,
+	"result" | DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>,
+	"strict"
+>;
 const resultUnwrapLeft = DEither.unwrapLeft(myResult);
 // unwrapLeft extrait la valeur des Left et conserve les autres résultats enveloppés.
 
 // Choisir une information lorsque le cas précis compte, quel que soit son statut.
 // La callback reçoit ici l’Error contenue dans le Left "fail-task".
-// DEither.Success<"result"> | DEither.Fail | DEither.Error<Error> | "test"
 const resultWhenHasInformation = DCommon.pipe(
 	myResult,
 	DEither.whenHasInformation(
@@ -36,44 +38,53 @@ const resultWhenHasInformation = DCommon.pipe(
 		(error) => "test" as const,
 	),
 );
-// "result" | Error | DEither.Fail | DEither.Error<Error>
+type _CheckResultWhenHasInformation = DCommon.ExpectType<
+	typeof resultWhenHasInformation,
+	DEither.Success<"result"> | DEither.Fail | DEither.Error<Error> | "test",
+	"strict"
+>;
 const resultUnwrapByInformation = DCommon.pipe(
 	myResult,
 	DEither.unwrapByInformation(
 		["success", "fail-task"],
 	),
 );
+type _CheckResultUnwrapByInformation = DCommon.ExpectType<typeof resultUnwrapByInformation, "result" | Error | DEither.Fail | DEither.Error<Error>, "strict">;
 // Les variantes non ciblées sont conservées dans le résultat et dans son type.
 
 // Les variantes Otherwise traitent aussi les cas non ciblés, au lieu de les transmettre.
-// "right" | "left"
 const resultWhenIsRightOtherwise = DCommon.pipe(
 	myResult,
 	DEither.whenIsRightOtherwise(
-		// "result"
-		(rightValue) => "right" as const,
-		// DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>
-		(leftResult) => "left" as const,
+		(rightValue) => {
+			type _CheckRightValue = DCommon.ExpectType<typeof rightValue, "result", "strict">;
+			return "right" as const;
+		},
+		(leftResult) => {
+			type _CheckLeftResult = DCommon.ExpectType<typeof leftResult, DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>, "strict">;
+			return "left" as const;
+		},
 	),
 );
+type _CheckResultWhenIsRightOtherwise = DCommon.ExpectType<typeof resultWhenIsRightOtherwise, "right" | "left", "strict">;
 
 // Les variantes OrThrow extraient les cas ciblés et lèvent une exception pour les autres.
-// "result" | Error
 const resultUnwrapByInformationOrThrow = DCommon.pipe(
 	myResult,
 	DEither.unwrapByInformationOrThrow(
 		["success", "fail-task"],
 	),
 );
+type _CheckResultUnwrapByInformationOrThrow = DCommon.ExpectType<typeof resultUnwrapByInformationOrThrow, "result" | Error, "strict">;
 // Utile notamment pour affirmer le résultat attendu dans un test unitaire.
 
 // Les predicates réduisent le type dans une branche conditionnelle.
 if (DEither.hasInformation(myResult, "success")) {
-	// DEither.Success<"result">
+	type _CheckSuccessResult = DCommon.ExpectType<typeof myResult, DEither.Success<"result">, "strict">;
 	void myResult;
 }
 // isRight et isLeft réduisent aussi le type selon le statut du résultat.
 if (DEither.isLeft(myResult)) {
-	// Error | void
 	const leftValue = DEither.unwrapLeft(myResult);
+	void leftValue;
 }

package/docs/concepts/01-fundamental/03-either/20-exhaustive-handling.ts

@@ -14,7 +14,6 @@ declare const myResult: (
 );
 
 // Sélectionner plusieurs variantes avec une décision explicite pour chacune.
-// DEither.Left<"fail-task", Error> | DEither.Fail | "test"
 const resultWhenIsSelected = DCommon.pipe(
 	myResult,
 	DEither.whenIsSelected(
@@ -27,7 +26,11 @@ const resultWhenIsSelected = DCommon.pipe(
 		(value) => "test" as const,
 	),
 );
-// DEither.Success<"result"> | Error | DEither.Left<"fail-task", Error> | DEither.Fail
+type _CheckResultWhenIsSelected = DCommon.ExpectType<
+	typeof resultWhenIsSelected,
+	DEither.Left<"fail-task", Error> | DEither.Fail | "test",
+	"strict"
+>;
 const resultUnwrapSelection = DCommon.pipe(
 	myResult,
 	DEither.unwrapSelection(
@@ -39,6 +42,11 @@ const resultUnwrapSelection = DCommon.pipe(
 		},
 	),
 );
+type _CheckResultUnwrapSelection = DCommon.ExpectType<
+	typeof resultUnwrapSelection,
+	DEither.Success<"result"> | Error | DEither.Left<"fail-task", Error> | DEither.Fail,
+	"strict"
+>;
 // Chaque information doit apparaître dans le sélecteur, même lorsqu’elle vaut false.
 // Ajouter une variante au contrat oblige à réviser la sélection à cet endroit.
 // Cela place la décision dans la couche qui doit la prendre, plutôt que de transmettre
@@ -51,17 +59,26 @@ const resultMatchInformation = DCommon.pipe(
 	myResult,
 	DEither.matchInformation(
 		{
-			// Error
-			"fail-task": (value) => "fail-task" as const,
-			// Error
-			error: (value) => "error" as const,
-			// void
-			fail: (value) => "fail" as const,
-			// "result"
-			success: (value) => "success" as const,
+			"fail-task": (value) => {
+				type _CheckFailTaskValue = DCommon.ExpectType<typeof value, Error, "strict">;
+				return "fail-task" as const;
+			},
+			error: (value) => {
+				type _CheckErrorValue = DCommon.ExpectType<typeof value, Error, "strict">;
+				return "error" as const;
+			},
+			fail: (value) => {
+				type _CheckFailValue = DCommon.ExpectType<typeof value, void, "strict">;
+				return "fail" as const;
+			},
+			success: (value) => {
+				type _CheckSuccessValue = DCommon.ExpectType<typeof value, "result", "strict">;
+				return "success" as const;
+			},
 		},
 	),
 );
+type _CheckResultMatchInformation = DCommon.ExpectType<typeof resultMatchInformation, "fail-task" | "success" | "fail" | "error", "strict">;
 // matchInformationOtherwise autorise un traitement partiel avec une branche de repli.
 const resultWithFallback = DCommon.pipe(
 	myResult,

package/docs/concepts/01-fundamental/03-either/30-composition.ts

@@ -3,6 +3,7 @@
  *
  * Enchaîner ou regrouper des opérations en arrêtant le traitement au premier Left.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DEither from "@duplojs/lang/either";
 import * as DArray from "@duplojs/lang/array";
 import * as DString from "@duplojs/lang/string";
@@ -18,8 +19,6 @@ declare const myResult: (
 // wrapper `Right` lui-même. Dès qu’un Left apparaît, les étapes suivantes sont
 // ignorées et ce Left est retourné. Une valeur finale brute est enveloppée dans
 // Success ; un Right final est conservé.
-// DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error>
-// | DEither.Left<"wrong", undefined> | DEither.Success<string>
 const resultRightPipe = DEither.rightPipe(
 	myResult,
 	DString.split(""),
@@ -32,8 +31,13 @@ const resultRightPipe = DEither.rightPipe(
 		return DEither.success(elementAt);
 	},
 	// Cette étape reçoit la string du Success retourné ci-dessus, pas son wrapper.
-	(value) => value.toUpperCase(),
+	DString.toUpperCase,
 );
+type _CheckResultRightPipe = DCommon.ExpectType<
+	typeof resultRightPipe,
+	DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error> | DEither.Left<"wrong", undefined> | DEither.Success<Uppercase<string>>,
+	"strict"
+>;
 // `rightAsyncPipe` applique le même arrêt sur Left et attend chaque étape
 // asynchrone. Une étape peut retourner un Either : s’il s’agit d’un Right,
 // l’étape suivante reçoit encore sa valeur déballée ; s’il s’agit d’un Left,
@@ -43,8 +47,13 @@ const asyncResult = DEither.rightAsyncPipe(
 	(value) => Promise.resolve(DEither.right("normalized", value)),
 	DString.toLowerCase,
 );
+type _CheckAsyncResult = DCommon.ExpectType<
+	typeof asyncResult,
+	Promise<DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error> | DEither.Success<"result">>,
+	"strict"
+>;
 // La dernière callback retourne une string brute : `asyncResult` est donc un
-// `Success<string>`, tandis que le `Right<"normalized", ...>` intermédiaire
+// `Success<"result">`, tandis que le `Right<"normalized", ...>` intermédiaire
 // n’est pas transmis comme wrapper à la callback suivante.
 // Si une étape intermédiaire produit un `Result` dont une information doit être
 // sélectionnée, composez sa sélection dans cette même callback avec
@@ -54,17 +63,16 @@ const asyncResult = DEither.rightAsyncPipe(
 // group rassemble les valeurs des Right dans un Success, ou retourne le premier Left.
 // Les getters sont appelés dans l’ordre et ceux placés après un Left ne sont pas exécutés.
 // Les valeurs déjà calculées avant l’appel à group ne peuvent pas être annulées.
-// DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error> | DEither.Error<"errorDeLaMort">
-// | DEither.Success<{
-//     result1: "result";
-//     result2: "mySuperResult";
-//     result3: never;
-// }>
 const groupResult = DEither.group({
 	result1: () => myResult,
 	result2: DEither.success("mySuperResult"),
 	result3: DEither.error("errorDeLaMort"),
 });
+type _CheckGroupResult = DCommon.ExpectType<typeof groupResult, DEither.Left<"fail-task", Error> | DEither.Fail | DEither.Error<Error> | DEither.Error<"errorDeLaMort"> | DEither.Success<{
+	result1: "result";
+	result2: "mySuperResult";
+	result3: never;
+}>, "strict">;
 // asyncGroup attend chaque résultat dans l’ordre, sans lancer les getters en parallèle.
 const asyncGroupResult = DEither.asyncGroup({
 	result1: () => Promise.resolve(myResult),

package/docs/concepts/01-fundamental/03-either/40-result-adaptation.ts

@@ -15,8 +15,6 @@ declare const myResult: (
 
 // Réinterpréter les statuts selon le contexte : true donne Right, false donne Left.
 // L’information et la valeur sont conservées ; le sélecteur couvre toutes les variantes.
-// DEither.Left<"fail", void> | DEither.Left<"error", Error> | DEither.Left<"success", "result">
-// | DEither.Right<"fail-task", Error>
 const resultKeepAsRightSelection = DCommon.pipe(
 	myResult,
 	DEither.keepAsRightSelection({
@@ -26,15 +24,23 @@ const resultKeepAsRightSelection = DCommon.pipe(
 		success: false,
 	}),
 );
+type _CheckResultKeepAsRightSelection = DCommon.ExpectType<
+	typeof resultKeepAsRightSelection,
+	DEither.Left<"fail", void> | DEither.Left<"error", Error> | DEither.Left<"success", "result"> | DEither.Right<"fail-task", Error>,
+	"strict"
+>;
 // keepAsRightByInformation sélectionne seulement les informations à considérer comme Right.
 // Toutes les autres deviennent Left, sans imposer de sélecteur exhaustif.
 const resultByInformation = DEither.keepAsRightByInformation(myResult, "fail-task");
 
 // Renommer une information adapte le vocabulaire du résultat au contexte appelant.
 // rewriteInformation conserve le statut et la valeur ; les variantes non ciblées restent identiques.
-// DEither.Fail | DEither.Error<Error> | DEither.Left<"fail-task", Error>
-// | DEither.Right<"new-information", "result">
 const resultRewriteInformation = DCommon.pipe(
 	myResult,
 	DEither.rewriteInformation({ success: "new-information" }),
 );
+type _CheckResultRewriteInformation = DCommon.ExpectType<
+	typeof resultRewriteInformation,
+	DEither.Fail | DEither.Error<Error> | DEither.Left<"fail-task", Error> | DEither.Right<"new-information", "result">,
+	"strict"
+>;

package/docs/concepts/01-fundamental/03-either/50-external-results.ts

@@ -25,8 +25,12 @@ import * as DCommon from "@duplojs/lang/common";
 
 declare function someFunction(): string | number | null | undefined;
 
-// DEither.None | DEither.Some<string> | DEither.Some<number>
 const resultToMaybe = DEither.toMaybe(someFunction());
+type _CheckResultToMaybeLine29 = DCommon.ExpectType<
+	typeof resultToMaybe,
+	DEither.None | DEither.Some<string> | DEither.Some<number>,
+	"strict"
+>;
 
 interface User {
 	name: string;
@@ -34,11 +38,11 @@ interface User {
 declare function findUser(): DEither.Maybe<User>;
 
 // Une transformation sur Some reçoit le User ; None est transmis sans exécuter la callback.
-// DEither.None | DEither.Success<string>
 const userName = DCommon.pipe(
 	findUser(),
 	DEither.whenIsRight((user) => DEither.success(user.name)),
 );
+type _CheckUserName = DCommon.ExpectType<typeof userName, DEither.None | DEither.Success<string>, "strict">;
 
 // Une API qui lève sur un refus prévisible doit être adaptée pour le rendre
 // exploitable comme résultat. Ne pas déduire la nature de l'échec du choix de cette API.
@@ -47,13 +51,22 @@ const userName = DCommon.pipe(
 // La capture est large : distinguer le refus documenté d'une cause technique.
 // Conserver cette cause dans le résultat jusqu'à sa consommation finale, sans
 // la requalifier en refus métier ni la relancer depuis une fonction réutilisable.
-// DEither.SafeCallbackError | DEither.SafeCallbackSuccess<"test">
 const resultSafeCallback = DEither.safeCallback(
 	() => "test" as const,
 );
+type _CheckSafeCallback = DCommon.ExpectType<
+	typeof resultSafeCallback,
+	DEither.SafeCallbackError | DEither.SafeCallbackSuccess<"test">,
+	"strict"
+>;
 // asyncSafeCallback capture aussi les rejets et retourne toujours une Promise de résultat.
 declare function loadValue(): Promise<string>;
 const asyncSafeResult = DEither.asyncSafeCallback(loadValue);
+type _CheckAsyncSafeResult = DCommon.ExpectType<
+	typeof asyncSafeResult,
+	Promise<DEither.SafeCallbackError | DEither.SafeCallbackSuccess<string>>,
+	"strict"
+>;
 
 // safeCallback gère aussi les promesses, mais une exception synchrone peut produire
 // directement un Left : préférer asyncSafeCallback pour un retour toujours asynchrone.

package/docs/concepts/01-fundamental/04-data-structure/10-structure.ts

@@ -3,60 +3,66 @@
  *
  * Construire et réutiliser des structures pour décrire des données simples ou composées.
  */
+import type * as DCommon from "@duplojs/lang/common";
 import * as DDataStructure from "@duplojs/lang/dataStructure";
 
 // Une Structure associe un type TypeScript à une représentation capable de vérifier la donnée.
 // Une TypeStructure repose sur un Type ; les autres structures composent plusieurs contrats.
 
-// string
 const nameStructure = DDataStructure.string();
+type _CheckNameStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof nameStructure>, string, "strict">;
 
-// number
 const ageStructure = DDataStructure.number();
+type _CheckAgeStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof ageStructure>, number, "strict">;
 
-// boolean
 const activeStructure = DDataStructure.boolean();
+type _CheckActiveStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof activeStructure>,
+	boolean,
+	"strict"
+>;
 
 // Les structures simples comme `string`, `number` ou `boolean` sont des
 // `TypeStructure`. Elles représentent directement un type fondamental.
 
-// "user"
 const userKindStructure = DDataStructure.literal("user");
+type _CheckUserKindStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof userKindStructure>,
+	"user",
+	"strict"
+>;
 
 // `literal` produit également une `TypeStructure` lorsqu'une seule valeur
 // est représentée.
 
-// "admin" | "member" | "guest"
 const roleStructure = DDataStructure.literal([
 	"admin",
 	"member",
 	"guest",
 ]);
+type _CheckRoleStructure = DCommon.ExpectType<DDataStructure.StructureValue<typeof roleStructure>, "admin" | "member" | "guest", "strict">;
 
 // Lorsque plusieurs valeurs sont représentées, `literal` construit une
 // `UnionStructure` composée de plusieurs `TypeStructure`.
 
-// {
-//     readonly street: string;
-//     readonly city: string;
-//     readonly zipCode: string;
-// }
 const addressStructure = DDataStructure.object({
 	street: DDataStructure.string(),
 	city: DDataStructure.string(),
 	zipCode: DDataStructure.string(),
 });
+type _CheckAddressStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof addressStructure>,
+	{
+		readonly street: string;
+		readonly city: string;
+		readonly zipCode: string;
+	},
+	"strict"
+>;
 
 // `ObjectStructure` compose plusieurs structures pour représenter les
 // propriétés d'un objet.
 
-// {
-//     readonly name: string;
-//     readonly age: number;
-//     readonly active: boolean;
-//     readonly role: "admin" | "member" | "guest";
-//     readonly address: Address;
-// }
 const userStructure = DDataStructure.object({
 	name: nameStructure,
 	age: ageStructure,
@@ -64,61 +70,77 @@ const userStructure = DDataStructure.object({
 	role: roleStructure,
 	address: addressStructure,
 });
+type _CheckUserStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof userStructure>,
+	{
+		readonly name: string;
+		readonly age: number;
+		readonly active: boolean;
+		readonly role: "admin" | "member" | "guest";
+		readonly address: DDataStructure.StructureValue<typeof addressStructure>;
+	},
+	"strict"
+>;
 
 // Une structure déjà définie peut et doit être réutilisée pour construire
 // des structures plus complexes.
 
-// readonly User[]
 const usersStructure = DDataStructure.array(
 	userStructure,
 );
+type _CheckUsersStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof usersStructure>,
+	readonly DDataStructure.StructureValue<typeof userStructure>[],
+	"strict"
+>;
 
 // `array` applique une même structure à chaque élément du tableau.
 
-// {
-//     readonly name: string;
-//     readonly bio?: string | undefined;
-// }
 const profileStructure = DDataStructure.object({
 	name: DDataStructure.string(),
 	bio: DDataStructure.optional(
 		DDataStructure.string(),
 	),
 });
+type _CheckProfileStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof profileStructure>,
+	{
+		readonly name: string;
+		readonly bio?: string | undefined;
+	},
+	"strict"
+>;
 
 type Profile = DDataStructure.StructureValue<typeof profileStructure>;
 
 // `optional` ajoute `undefined` à une structure.
 // Dans un `ObjectStructure`, cela permet également d'omettre la propriété.
 
-// {
-//     readonly user: User | null;
-// }
 const sessionStructure = DDataStructure.object({
 	user: DDataStructure.nullable(
 		userStructure,
 	),
 });
+type _CheckSessionStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof sessionStructure>,
+	{ readonly user: DDataStructure.StructureValue<typeof userStructure> | null },
+	"strict"
+>;
 
 // `nullable` ajoute `null` à une structure sans rendre la propriété optionnelle.
 
-// string | number
 const identifierStructure = DDataStructure.union([
 	DDataStructure.string(),
 	DDataStructure.number(),
 ]);
+type _CheckIdentifierStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof identifierStructure>,
+	string | number,
+	"strict"
+>;
 
 // `union` représente plusieurs structures possibles.
 
-// {
-//     readonly type: "user-created";
-//     readonly user: User;
-// }
-// |
-// {
-//     readonly type: "user-deleted";
-//     readonly userId: string | number;
-// }
 const eventStructure = DDataStructure.union([
 	DDataStructure.object({
 		type: DDataStructure.literal("user-created"),
@@ -129,14 +151,23 @@ const eventStructure = DDataStructure.union([
 		userId: identifierStructure,
 	}),
 ]);
+interface UserCreatedEvent {
+	readonly type: "user-created";
+	readonly user: DDataStructure.StructureValue<typeof userStructure>;
+}
+interface UserDeletedEvent {
+	readonly type: "user-deleted";
+	readonly userId: string | number;
+}
+type _CheckEventStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof eventStructure>,
+	UserCreatedEvent | UserDeletedEvent,
+	"strict"
+>;
 
 // Les unions peuvent représenter plusieurs formes d'objets.
 // Des valeurs littérales peuvent être utilisées pour créer une union discriminée.
 
-// {
-//     readonly fr: string;
-//     readonly en: string;
-// }
 const translationsStructure = DDataStructure.record(
 	DDataStructure.literal([
 		"fr",
@@ -144,43 +175,50 @@ const translationsStructure = DDataStructure.record(
 	]),
 	DDataStructure.string(),
 );
+type _CheckTranslationsStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof translationsStructure>,
+	{
+		readonly fr: string;
+		readonly en: string;
+	},
+	"strict"
+>;
 
 // `record` représente un objet dont les clés possibles et les valeurs
 // sont elles-mêmes décrites par des structures.
 
-// {
-//     readonly name?: string | undefined;
-//     readonly age?: number | undefined;
-//     readonly active?: boolean | undefined;
-//     readonly role?: "admin" | "member" | "guest" | undefined;
-//     readonly address?: Address | undefined;
-// }
 const updateUserStructure = DDataStructure.partial(
 	userStructure,
 );
+type _CheckUpdateUserStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof updateUserStructure>,
+	{
+		readonly name?: string | undefined;
+		readonly age?: number | undefined;
+		readonly active?: boolean | undefined;
+		readonly role?: "admin" | "member" | "guest" | undefined;
+		readonly address?: DDataStructure.StructureValue<typeof addressStructure> | undefined;
+	},
+	"strict"
+>;
 
 // `partial` transforme toutes les propriétés d'un `ObjectStructure`
 // en propriétés optionnelles.
 
-// {
-//     readonly name: string;
-//     readonly bio: string;
-// }
 const requiredProfileStructure = DDataStructure.required(
 	profileStructure,
 );
+type _CheckRequiredProfileStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof requiredProfileStructure>,
+	{
+		readonly name: string;
+		readonly bio: string;
+	},
+	"strict"
+>;
 
 // `required` réalise l'opération inverse et rend les propriétés obligatoires.
 
-// {
-//     readonly name: string;
-//     readonly age: number;
-//     readonly active: boolean;
-//     readonly role: "admin" | "member" | "guest";
-//     readonly address: Address;
-//     readonly id: string | number;
-//     readonly createdAt: string;
-// }
 const persistedUserStructure = DDataStructure.extend(
 	userStructure,
 	{
@@ -188,6 +226,19 @@ const persistedUserStructure = DDataStructure.extend(
 		createdAt: DDataStructure.string(),
 	},
 );
+type _CheckPersistedUserStructure = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof persistedUserStructure>,
+	{
+		readonly name: string;
+		readonly age: number;
+		readonly active: boolean;
+		readonly role: "admin" | "member" | "guest";
+		readonly address: DDataStructure.StructureValue<typeof addressStructure>;
+		readonly id: string | number;
+		readonly createdAt: string;
+	},
+	"strict"
+>;
 
 // `extend` crée un nouvel `ObjectStructure` en ajoutant des propriétés
 // à une structure objet existante.