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

package/docs/concepts/01-fundamental/06-modeling/30-tagged-object.ts

@@ -16,10 +16,6 @@ import * as DEither from "@duplojs/lang/either";
 // Le code métier n'a pas à choisir ni à manipuler la clé utilisée pour
 // enregistrer le tag.
 //
-// DModeling.ObjectTag<"EmailNotification"> & {
-//     readonly email: string;
-//     readonly subject: string;
-// }
 const EmailNotification = DModeling.createTaggedObject(
 	"EmailNotification",
 	{
@@ -28,17 +24,20 @@ const EmailNotification = DModeling.createTaggedObject(
 	},
 );
 type EmailNotification = DDataStructure.StructureValue<typeof EmailNotification>;
+type _CheckEmailNotification = DCommon.ExpectType<
+	EmailNotification,
+	DModeling.ObjectTag<"EmailNotification"> & {
+		readonly email: string;
+		readonly subject: string;
+	},
+	"strict"
+>;
 
 // Les propriétés peuvent être définies directement avec des `DataStructure`.
 //
 // Contrairement à une `Entity`, un `TaggedObject` n'impose pas que ses
 // propriétés soient des `NewType`.
 //
-// DModeling.ObjectTag<"SmsNotification"> & {
-//     readonly phone: string;
-//     readonly message: string;
-//     readonly attempts: number;
-// }
 const SmsNotification = DModeling.createTaggedObject(
 	"SmsNotification",
 	{
@@ -48,6 +47,11 @@ const SmsNotification = DModeling.createTaggedObject(
 	},
 );
 type SmsNotification = DDataStructure.StructureValue<typeof SmsNotification>;
+type _CheckSmsNotification = DCommon.ExpectType<SmsNotification, DModeling.ObjectTag<"SmsNotification"> & {
+	readonly phone: string;
+	readonly message: string;
+	readonly attempts: number;
+}, "strict">;
 
 // Plusieurs `TaggedObject` peuvent former une union discriminée.
 //
@@ -69,29 +73,36 @@ const destination = DPattern.matchWithTaggedObject(
 		SmsNotification: (smsNotification) => smsNotification.phone,
 	},
 );
+type _CheckDestination = DCommon.ExpectType<typeof destination, string, "strict">;
 
 // L'identité peut également être récupérée directement.
 //
-// "EmailNotification" | "SmsNotification"
 const notificationType = DModeling.getTagValue(notification);
+type _CheckNotificationType = DCommon.ExpectType<
+	typeof notificationType,
+	"EmailNotification" | "SmsNotification",
+	"strict"
+>;
 
 // `hasTagValue` permet de tester une identité et affine simultanément
 // le type de la valeur.
 //
 // Dans cette branche, `notification` est précisément un `EmailNotification`.
 if (DModeling.hasTagValue(notification, "EmailNotification")) {
+	type _CheckEmailBranch = DCommon.ExpectType<typeof notification, EmailNotification, "strict">;
 	const subject = notification.subject;
+	type _CheckSubject = DCommon.ExpectType<typeof subject, string, "strict">;
 }
 
 // `new` est utilisé lorsque les propriétés possèdent déjà le typage attendu.
 //
 // Il construit le `TaggedObject` et lui associe son identité.
 //
-// EmailNotification
 const emailNotification = EmailNotification.new({
 	email: "user@example.com",
 	subject: "Account created",
 });
+type _CheckEmailNotificationValue = DCommon.ExpectType<typeof emailNotification, EmailNotification, "strict">;
 
 // L'identité fait partie de la structure du `TaggedObject`.
 //
@@ -115,12 +126,16 @@ declare const externalEmailNotification: {
 //
 // L'hydratation peut échouer, son résultat est donc représenté par un `Either`.
 
-// DEither.Left<"async-error", DDataStructure.ErrorPromise>
-// | DEither.Left<"map-error", DDataStructure.Error>
-// | DEither.Right<"map-success", EmailNotification>
 const maybeEmailNotification = EmailNotification.map(
 	externalEmailNotification,
 );
+type _CheckMaybeEmailNotificationLine121 = DCommon.ExpectType<
+	typeof maybeEmailNotification,
+	DEither.Left<"async-error", DDataStructure.ErrorPromise>
+| DEither.Left<"map-error", DDataStructure.Error>
+| DEither.Right<"map-success", EmailNotification>,
+	"strict"
+>;
 
 // Une fois hydraté, le tag fait partie de la donnée.
 //
@@ -129,12 +144,6 @@ const maybeEmailNotification = EmailNotification.map(
 // Il n'a donc pas besoin d'être hydraté une seconde fois simplement
 // parce qu'il traverse une frontière entre deux services.
 //
-// DEither.Left<"async-error", DDataStructure.ErrorPromise>
-// | DEither.Left<"map-error", DDataStructure.Error>
-// | (DModeling.ObjectTag<"EmailNotification"> & {
-//     readonly email: string;
-//     readonly subject: string;
-// })
 const mappedEmailNotification = DCommon.pipe(
 	EmailNotification.map({
 		email: "user@example.com",
@@ -142,6 +151,16 @@ const mappedEmailNotification = DCommon.pipe(
 	}),
 	DEither.unwrapRight,
 );
+type _CheckMappedEmailNotification = DCommon.ExpectType<
+	typeof mappedEmailNotification,
+	DEither.Left<"async-error", DDataStructure.ErrorPromise>
+		| DEither.Left<"map-error", DDataStructure.Error>
+		| DModeling.ObjectTag<"EmailNotification"> & {
+			readonly email: string;
+			readonly subject: string;
+		},
+	"strict"
+>;
 
 // `decodeMap` suit le même principe que `map`, mais commence par décoder
 // la représentation externe avec les codecs fournis.
@@ -149,9 +168,6 @@ const mappedEmailNotification = DCommon.pipe(
 // Ici, `attempts` provient par exemple d'une représentation string avant
 // de retrouver son type métier `number`.
 
-// DEither.Left<"async-error", DDataStructure.ErrorPromise>
-// | DEither.Left<"map-error", DDataStructure.Error>
-// | DEither.Right<"map-success", SmsNotification>
 const maybeSmsNotification = SmsNotification.decodeMap(
 	DDataStructure.codecsString,
 	{
@@ -160,6 +176,13 @@ const maybeSmsNotification = SmsNotification.decodeMap(
 		attempts: DCommon.cast("1"),
 	},
 );
+type _CheckMaybeSmsNotificationLine155 = DCommon.ExpectType<
+	typeof maybeSmsNotification,
+	DEither.Left<"async-error", DDataStructure.ErrorPromise>
+| DEither.Left<"map-error", DDataStructure.Error>
+| DEither.Right<"map-success", SmsNotification>,
+	"strict"
+>;
 
 // `update` reconstruit un `TaggedObject` possédant la même identité
 // en remplaçant uniquement les propriétés fournies.

package/docs/concepts/01-fundamental/06-modeling/40-entity-lifecycle.ts

@@ -87,23 +87,21 @@ export namespace User {
 	// Ici, chacun porte au runtime la payload de l'état qu'il certifie.
 	// Une fonction exigeant `User.Entity & User.AwaitingValidationFlag` reçoit ainsi
 	// une entité dont l'état d'attente est prouvé, avec son `AwaitingValidationState`.
-	export type AwaitingValidationFlag = DModeling.Flag<
-		"AwaitingValidation",
-		AwaitingValidationState
-	>;
+	// Déclarer d'abord la factory avec le nom, la payload et la structure d'entité,
+	// puis en dériver le type avec `GetFlag`.
 	export const AwaitingValidationFlag = DModeling.createFlag<
-		AwaitingValidationFlag,
+		"AwaitingValidation",
+		AwaitingValidationState,
 		typeof Entity
 	>("AwaitingValidation");
+	export type AwaitingValidationFlag = DModeling.GetFlag<typeof AwaitingValidationFlag>;
 
-	export type ValidateFlag = DModeling.Flag<
-		"Validate",
-		ValidateState
-	>;
 	export const ValidateFlag = DModeling.createFlag<
-		ValidateFlag,
+		"Validate",
+		ValidateState,
 		typeof Entity
 	>("Validate");
+	export type ValidateFlag = DModeling.GetFlag<typeof ValidateFlag>;
 
 	// Après hydratation, `state` reste typé comme l'union des états possibles.
 	// `refineState` inspecte sa valeur et ajoute le flag correspondant sans modifier
@@ -132,17 +130,16 @@ export namespace User {
 // y compris un changement de propriété qui conserve le même état nommé.
 // Sa payload décrit l'événement et reste portée par l'entité après application du fait.
 // Ici, la création place toujours l'utilisateur en attente de validation.
-export type UserCreateFact = DModeling.Fact<
+// `createFact` reçoit les mêmes trois génériques que `createFlag`, puis construit `run`
+// dans un second appel. `GetFact` extrait le type du fait depuis cette factory.
+export const UserCreateFact = DModeling.createFact<
 	"UserCreated",
 	{
 		id: User.Id;
 		age: User.Age;
 		name: User.Name;
 		state: User.AwaitingValidationState;
-	}
->;
-export const UserCreateFact = DModeling.createFact<
-	UserCreateFact,
+	},
 	typeof User.Entity
 >("UserCreated")(
 	({ applyFact }) => (
@@ -156,7 +153,7 @@ export const UserCreateFact = DModeling.createFact<
 		//
 		// Elle contient notamment l'état produit par cette étape du cycle de vie,
 		// ce qui permet de conserver cette information avec la `Fact`.
-		const payload: DModeling.GetFactPayload<UserCreateFact> = {
+		const payload = {
 			id: params.id,
 			age: params.age,
 			name: params.name,
@@ -179,20 +176,19 @@ export const UserCreateFact = DModeling.createFact<
 	},
 );
 
+export type UserCreateFact = DModeling.GetFact<typeof UserCreateFact>;
+
 // Cette `Fact` représente la transition entre l'attente de validation
 // et l'état validé.
 //
 // Sa signature fait elle-même partie de la règle métier :
 // seules les entités possédant `AwaitingValidationFlag` peuvent effectuer
 // cette transition.
-export type ValidateUserFact = DModeling.Fact<
+export const ValidateUserFact = DModeling.createFact<
 	"ValidateUserFact",
 	{
 		state: User.ValidateState;
-	}
->;
-export const ValidateUserFact = DModeling.createFact<
-	ValidateUserFact,
+	},
 	typeof User.Entity
 >("ValidateUserFact")(
 	({ applyFact }) => (
@@ -205,7 +201,7 @@ export const ValidateUserFact = DModeling.createFact<
 		//
 		// Le fait `ValidateUserFact` conserve donc également les informations
 		// produites lors de cette transition.
-		const payload: DModeling.GetFactPayload<ValidateUserFact> = {
+		const payload = {
 			state: User.ValidateState.new({
 				address: params.address,
 				validateAt: DChrono.now(),
@@ -228,6 +224,8 @@ export const ValidateUserFact = DModeling.createFact<
 	},
 );
 
+export type ValidateUserFact = DModeling.GetFact<typeof ValidateUserFact>;
+
 declare const id: User.Id;
 declare const age: User.Age;
 declare const name: User.Name;
@@ -240,6 +238,11 @@ const createdUser = DCommon.pipe(
 	}),
 	DEither.unwrapRight,
 );
+type _CheckCreatedUser = DCommon.ExpectType<
+	typeof createdUser.state,
+	User.AwaitingValidationState,
+	"strict"
+>;
 
 declare const address: User.Address;
 
@@ -255,17 +258,6 @@ declare const address: User.Address;
 // - `ValidateFlag` prouve le nouvel état ;
 // - `UserCreated` a été remplacée par `ValidateUserFact`.
 //
-// & DModeling.Entity<"User">
-// & {
-//     readonly name: string & DModeling.NewType<"UserName", Trimmed | MinCharacters<3> | MaxCharacters<45>>;
-//     readonly id: string & DModeling.NewType<"UserId", Uuid>;
-//     readonly age: number & DModeling.NewType<"UserAge", Integer | Positive>;
-//     readonly state: User.ValidateState;
-// }
-// & DModeling.Flag<"Validate", User.ValidateState>
-// & DModeling.Fact<"ValidateUserFact", {
-//     state: User.ValidateState;
-// }>
 const validateUser = DCommon.pipe(
 	ValidateUserFact.run(
 		createdUser,
@@ -273,3 +265,8 @@ const validateUser = DCommon.pipe(
 	),
 	DEither.unwrapRight,
 );
+type _CheckValidatedUser = DCommon.ExpectType<
+	typeof validateUser.state,
+	User.ValidateState,
+	"strict"
+>;

package/docs/concepts/01-fundamental/07-discrimination/10-entity.ts

@@ -33,17 +33,25 @@ declare const entity: Entity;
 // Chaque callback reçoit directement le type précis correspondant
 // au nom de l'entité.
 
-// string | number
 const matchedEntity = DPattern.matchWithEntity(
 	entity,
 	{
-		// User
-		User: (user) => user.name,
+		User: (user) => {
+			type _CheckUser = DCommon.ExpectType<typeof user, User, "strict">;
+			return user.name;
+		},
 
-		// Admin
-		Admin: (admin) => admin.permissions.length,
+		Admin: (admin) => {
+			type _CheckAdmin = DCommon.ExpectType<typeof admin, Admin, "strict">;
+			return admin.permissions.length;
+		},
 	},
 );
+type _CheckMatchedEntityLine37 = DCommon.ExpectType<
+	typeof matchedEntity,
+	string | number,
+	"strict"
+>;
 
 // La sélection exhaustive crée un point d'ancrage dans le typage.
 //
@@ -56,17 +64,25 @@ const matchedEntity = DPattern.matchWithEntity(
 // `matchWithEntity` possède également une forme curried afin d'être
 // directement utilisée dans un pipe.
 
-// string | number
 const matchedEntityInPipe = DCommon.pipe(
 	entity,
 	DPattern.matchWithEntity({
-		// User
-		User: (user) => user.name,
+		User: (user) => {
+			type _CheckUser = DCommon.ExpectType<typeof user, User, "strict">;
+			return user.name;
+		},
 
-		// Admin
-		Admin: (admin) => admin.permissions.length,
+		Admin: (admin) => {
+			type _CheckAdmin = DCommon.ExpectType<typeof admin, Admin, "strict">;
+			return admin.permissions.length;
+		},
 	}),
 );
+type _CheckMatchedEntityInPipeLine60 = DCommon.ExpectType<
+	typeof matchedEntityInPipe,
+	string | number,
+	"strict"
+>;
 
 // `matchWithEntityOtherwise` permet de ne sélectionner explicitement
 // qu'une partie des entités.
@@ -74,31 +90,47 @@ const matchedEntityInPipe = DCommon.pipe(
 // `otherwise` reçoit uniquement les entités qui n'ont pas déjà
 // été prises en charge par le matcher.
 
-// string | number
 const matchedEntityOtherwise = DPattern.matchWithEntityOtherwise(
 	entity,
 	{
-		// User
-		User: (user) => user.name,
+		User: (user) => {
+			type _CheckUser = DCommon.ExpectType<typeof user, User, "strict">;
+			return user.name;
+		},
+	},
+	(admin) => {
+		type _CheckAdmin = DCommon.ExpectType<typeof admin, Admin, "strict">;
+		return admin.permissions.length;
 	},
-	// Admin
-	(admin) => admin.permissions.length,
 );
+type _CheckMatchedEntityOtherwiseLine78 = DCommon.ExpectType<
+	typeof matchedEntityOtherwise,
+	string | number,
+	"strict"
+>;
 
 // La forme curried est également disponible.
 //
 // Le typage de `otherwise` évolue avec les handlers déjà déclarés.
 // Il représente toujours précisément le reste de l'union.
 
-// string | number
 const matchedEntityOtherwiseInPipe = DCommon.pipe(
 	entity,
 	DPattern.matchWithEntityOtherwise(
 		{
-			// User
-			User: (user) => user.name,
+			User: (user) => {
+				type _CheckUser = DCommon.ExpectType<typeof user, User, "strict">;
+				return user.name;
+			},
+		},
+		(admin) => {
+			type _CheckAdmin = DCommon.ExpectType<typeof admin, Admin, "strict">;
+			return admin.permissions.length;
 		},
-		// Admin
-		(admin) => admin.permissions.length,
 	),
 );
+type _CheckMatchedEntityOtherwiseInPipeLine94 = DCommon.ExpectType<
+	typeof matchedEntityOtherwiseInPipe,
+	string | number,
+	"strict"
+>;

package/docs/concepts/01-fundamental/07-discrimination/20-fact.ts

@@ -55,21 +55,25 @@ declare const user: User;
 // correspondant au nom sélectionné. La payload est accessible sur cette valeur avec factKind.
 // Cette lecture fonctionne dans les formes directe et curifiée.
 
-// string | number
 const matchedFact = DPattern.matchWithFact(
 	user,
 	{
-		// UserCreated
-		UserCreated: (createdUser) => (
-			DModeling.factKind.getValue(createdUser).payload.name
-		),
-
-		// UserDeleted
-		UserDeleted: (deletedUser) => (
-			DModeling.factKind.getValue(deletedUser).payload.reason.length
-		),
+		UserCreated: (createdUser) => {
+			type _CheckCreatedUser = DCommon.ExpectType<typeof createdUser, UserCreated, "strict">;
+			return DModeling.factKind.getValue(createdUser).payload.name;
+		},
+
+		UserDeleted: (deletedUser) => {
+			type _CheckDeletedUser = DCommon.ExpectType<typeof deletedUser, UserDeleted, "strict">;
+			return DModeling.factKind.getValue(deletedUser).payload.reason.length;
+		},
 	},
 );
+type _CheckMatchedFactLine59 = DCommon.ExpectType<
+	typeof matchedFact,
+	string | number,
+	"strict"
+>;
 
 // La sélection exhaustive crée un point d'ancrage dans le typage.
 //
@@ -82,21 +86,25 @@ const matchedFact = DPattern.matchWithFact(
 // `matchWithFact` possède également une forme curried afin d'être
 // directement utilisée dans un pipe.
 
-// string | number
 const matchedFactInPipe = DCommon.pipe(
 	user,
 	DPattern.matchWithFact({
-		// UserCreated
-		UserCreated: (createdUser) => (
-			DModeling.factKind.getValue(createdUser).payload.name
-		),
-
-		// UserDeleted
-		UserDeleted: (deletedUser) => (
-			DModeling.factKind.getValue(deletedUser).payload.reason.length
-		),
+		UserCreated: (createdUser) => {
+			type _CheckCreatedUser = DCommon.ExpectType<typeof createdUser, UserCreated, "strict">;
+			return DModeling.factKind.getValue(createdUser).payload.name;
+		},
+
+		UserDeleted: (deletedUser) => {
+			type _CheckDeletedUser = DCommon.ExpectType<typeof deletedUser, UserDeleted, "strict">;
+			return DModeling.factKind.getValue(deletedUser).payload.reason.length;
+		},
 	}),
 );
+type _CheckMatchedFactInPipeLine86 = DCommon.ExpectType<
+	typeof matchedFactInPipe,
+	string | number,
+	"strict"
+>;
 
 // `matchWithFactOtherwise` permet de ne sélectionner explicitement
 // qu'une partie des facts.
@@ -104,39 +112,47 @@ const matchedFactInPipe = DCommon.pipe(
 // `otherwise` reçoit uniquement les valeurs portant les facts
 // qui n'ont pas déjà été prises en charge par le matcher.
 
-// string | UserDeleted
 const matchedFactOtherwise = DPattern.matchWithFactOtherwise(
 	user,
 	{
-		// UserCreated
-		UserCreated: (createdUser) => (
-			DModeling.factKind.getValue(createdUser).payload.name
-		),
+		UserCreated: (createdUser) => {
+			type _CheckCreatedUser = DCommon.ExpectType<typeof createdUser, UserCreated, "strict">;
+			return DModeling.factKind.getValue(createdUser).payload.name;
+		},
+	},
+	(deletedUser) => {
+		type _CheckDeletedUser = DCommon.ExpectType<typeof deletedUser, UserDeleted, "strict">;
+		return deletedUser;
 	},
-	// UserDeleted
-	(deletedUser) => (
-		deletedUser
-	),
 );
+type _CheckMatchedFactOtherwiseLine108 = DCommon.ExpectType<
+	typeof matchedFactOtherwise,
+	string | UserDeleted,
+	"strict"
+>;
 
 // La forme curried est également disponible.
 //
 // Le typage de `otherwise` évolue avec les handlers déjà déclarés.
 // Il représente toujours précisément le reste de l'union de facts.
 
-// string | UserDeleted
 const matchedFactOtherwiseInPipe = DCommon.pipe(
 	user,
 	DPattern.matchWithFactOtherwise(
 		{
-			// UserCreated
-			UserCreated: (createdUser) => (
-				DModeling.factKind.getValue(createdUser).payload.name
-			),
+			UserCreated: (createdUser) => {
+				type _CheckCreatedUser = DCommon.ExpectType<typeof createdUser, UserCreated, "strict">;
+				return DModeling.factKind.getValue(createdUser).payload.name;
+			},
+		},
+		(deletedUser) => {
+			type _CheckDeletedUser = DCommon.ExpectType<typeof deletedUser, UserDeleted, "strict">;
+			return deletedUser;
 		},
-		// UserDeleted
-		(deletedUser) => (
-			deletedUser
-		),
 	),
 );
+type _CheckMatchedFactOtherwiseInPipeLine128 = DCommon.ExpectType<
+	typeof matchedFactOtherwiseInPipe,
+	string | UserDeleted,
+	"strict"
+>;

package/docs/concepts/01-fundamental/07-discrimination/30-tagged-object.ts

@@ -34,17 +34,25 @@ declare const notification: Notification;
 // Chaque callback reçoit directement le `TaggedObject` précis
 // correspondant au tag sélectionné.
 
-// string
 const matchedNotification = DPattern.matchWithTaggedObject(
 	notification,
 	{
-		// EmailNotification
-		EmailNotification: (emailNotification) => emailNotification.email,
+		EmailNotification: (emailNotification) => {
+			type _CheckEmailNotification = DCommon.ExpectType<typeof emailNotification, EmailNotification, "strict">;
+			return emailNotification.email;
+		},
 
-		// SmsNotification
-		SmsNotification: (smsNotification) => smsNotification.phone,
+		SmsNotification: (smsNotification) => {
+			type _CheckSmsNotification = DCommon.ExpectType<typeof smsNotification, SmsNotification, "strict">;
+			return smsNotification.phone;
+		},
 	},
 );
+type _CheckMatchedNotificationLine38 = DCommon.ExpectType<
+	typeof matchedNotification,
+	string,
+	"strict"
+>;
 
 // La sélection exhaustive crée un point d'ancrage dans le typage.
 //
@@ -57,17 +65,25 @@ const matchedNotification = DPattern.matchWithTaggedObject(
 // `matchWithTaggedObject` possède également une forme curried afin d'être
 // directement utilisée dans un pipe.
 
-// string
 const matchedNotificationInPipe = DCommon.pipe(
 	notification,
 	DPattern.matchWithTaggedObject({
-		// EmailNotification
-		EmailNotification: (emailNotification) => emailNotification.email,
+		EmailNotification: (emailNotification) => {
+			type _CheckEmailNotification = DCommon.ExpectType<typeof emailNotification, EmailNotification, "strict">;
+			return emailNotification.email;
+		},
 
-		// SmsNotification
-		SmsNotification: (smsNotification) => smsNotification.phone,
+		SmsNotification: (smsNotification) => {
+			type _CheckSmsNotification = DCommon.ExpectType<typeof smsNotification, SmsNotification, "strict">;
+			return smsNotification.phone;
+		},
 	}),
 );
+type _CheckMatchedNotificationInPipeLine61 = DCommon.ExpectType<
+	typeof matchedNotificationInPipe,
+	string,
+	"strict"
+>;
 
 // `matchWithTaggedObjectOtherwise` permet de ne sélectionner explicitement
 // qu'une partie des tags.
@@ -75,31 +91,47 @@ const matchedNotificationInPipe = DCommon.pipe(
 // `otherwise` reçoit uniquement les `TaggedObject` qui n'ont pas déjà
 // été pris en charge par le matcher.
 
-// string
 const matchedNotificationOtherwise = DPattern.matchWithTaggedObjectOtherwise(
 	notification,
 	{
-		// EmailNotification
-		EmailNotification: (emailNotification) => emailNotification.email,
+		EmailNotification: (emailNotification) => {
+			type _CheckEmailNotification = DCommon.ExpectType<typeof emailNotification, EmailNotification, "strict">;
+			return emailNotification.email;
+		},
+	},
+	(smsNotification) => {
+		type _CheckSmsNotification = DCommon.ExpectType<typeof smsNotification, SmsNotification, "strict">;
+		return smsNotification.phone;
 	},
-	// SmsNotification
-	(smsNotification) => smsNotification.phone,
 );
+type _CheckMatchedNotificationOtherwiseLine79 = DCommon.ExpectType<
+	typeof matchedNotificationOtherwise,
+	string,
+	"strict"
+>;
 
 // La forme curried est également disponible.
 //
 // Le typage de `otherwise` évolue avec les handlers déjà déclarés.
 // Il représente toujours précisément le reste de l'union de `TaggedObject`.
 
-// string
 const matchedNotificationOtherwiseInPipe = DCommon.pipe(
 	notification,
 	DPattern.matchWithTaggedObjectOtherwise(
 		{
-			// EmailNotification
-			EmailNotification: (emailNotification) => emailNotification.email,
+			EmailNotification: (emailNotification) => {
+				type _CheckEmailNotification = DCommon.ExpectType<typeof emailNotification, EmailNotification, "strict">;
+				return emailNotification.email;
+			},
+		},
+		(smsNotification) => {
+			type _CheckSmsNotification = DCommon.ExpectType<typeof smsNotification, SmsNotification, "strict">;
+			return smsNotification.phone;
 		},
-		// SmsNotification
-		(smsNotification) => smsNotification.phone,
 	),
 );
+type _CheckMatchedNotificationOtherwiseInPipeLine95 = DCommon.ExpectType<
+	typeof matchedNotificationOtherwiseInPipe,
+	string,
+	"strict"
+>;