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

package/docs/API/10-lang/10-string/10-stringify.ts

@@ -0,0 +1,11 @@
+/**
+ * @title DString.stringify
+ *
+ * Convertir une valeur quelconque en représentation textuelle sans laisser `undefined` au résultat.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.stringify({ status: "ready" });
+// La valeur obtenue est la représentation JSON "{\"status\":\"ready\"}".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;

package/docs/API/10-lang/10-string/10-substring.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.substring
+ *
+ * Extraire une sous-chaîne selon les règles de `substring`.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.substring("hello world", 6);
+// La valeur obtenue est "world".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.substring(6),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-test.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.test
+ *
+ * Tester une chaîne avec une expression régulière.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.test("order-42", /\d+$/);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42",
+	DString.test(/\d+$/),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;

package/docs/API/10-lang/10-string/10-to.ts

@@ -0,0 +1,11 @@
+/**
+ * @title DString.to
+ *
+ * Convertir une valeur stringifiable en chaîne en conservant les littéraux connus lorsque c'est possible.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.to(42);
+// La valeur obtenue est "42" et son type reste littéral.
+type _CheckResult = DCommon.ExpectType<typeof result, "42", "strict">;

package/docs/API/10-lang/10-string/10-toLowerCase.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.toLowerCase
+ *
+ * Convertir une chaîne en minuscules.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.toLowerCase("DuploJS");
+// La valeur obtenue est "duplojs".
+type _CheckResult = DCommon.ExpectType<typeof result, "duplojs", "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.toLowerCase,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "duplojs", "strict">;

package/docs/API/10-lang/10-string/10-toUpperCase.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.toUpperCase
+ *
+ * Convertir une chaîne en majuscules.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.toUpperCase("DuploJS");
+// La valeur obtenue est "DUPLOJS".
+type _CheckResult = DCommon.ExpectType<typeof result, "DUPLOJS", "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.toUpperCase,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "DUPLOJS", "strict">;

package/docs/API/10-lang/10-string/10-trim.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trim
+ *
+ * Supprimer les espaces au début et à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trim("  DuploJS  ");
+// La valeur obtenue est "DuploJS" et elle est marquée comme Trimmed.
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.Trimmed & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trim,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.Trimmed & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-trimEnd.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trimEnd
+ *
+ * Supprimer les espaces à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trimEnd("  DuploJS  ");
+// La valeur obtenue est "  DuploJS".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trimEnd,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-trimStart.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.trimStart
+ *
+ * Supprimer les espaces au début d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.trimStart("  DuploJS  ");
+// La valeur obtenue est "DuploJS  ".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"  DuploJS  ",
+	DString.trimStart,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

package/docs/API/10-lang/10-string/10-uncapitalize.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.uncapitalize
+ *
+ * Mettre en minuscule le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.uncapitalize("Duplo");
+// La valeur obtenue est "duplo".
+type _CheckResult = DCommon.ExpectType<typeof result, "duplo", "strict">;
+
+const piped = DCommon.pipe(
+	"Duplo",
+	DString.uncapitalize,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "duplo", "strict">;

package/docs/API/10-lang/10-string/index.llms.md

@@ -0,0 +1,208 @@
+## DString
+
+Fonctions de manipulation, recherche, validation et transformation des chaînes de caractères, avec des formes curifiées et des contraintes de typage lorsque l'API peut les établir.
+
+### [DString.at](10-at.ts)
+
+Lire le caractère situé à un index, avec `undefined` lorsque l'index est hors limites.
+ 
+### [DString.capitalize](10-capitalize.ts)
+
+Mettre en majuscule le premier caractère d'une chaîne.
+ 
+### [DString.charAt](10-charAt.ts)
+
+Lire le caractère situé à un index positif ou nul.
+ 
+### [DString.concat](10-concat.ts)
+
+Ajouter une ou plusieurs chaînes à la fin d'une chaîne.
+ 
+### [DString.endsWith](10-endsWith.ts)
+
+Tester si une chaîne se termine par une sous-chaîne.
+ 
+### [DString.extract](10-extract.ts)
+
+Extraire la première occurrence d'un motif avec ses groupes et sa position.
+ 
+### [DString.extractAll](10-extractAll.ts)
+
+Produire les occurrences d'un motif global sous forme de génératrice.
+ 
+### [DString.first](10-first.ts)
+
+Lire le premier caractère d'une chaîne.
+ 
+### [DString.includes](10-includes.ts)
+
+Tester si une chaîne contient une sous-chaîne.
+ 
+### [DString.indexOf](10-indexOf.ts)
+
+Retourner la position d'une sous-chaîne, ou `undefined` si elle est absente.
+ 
+### [DString.isComposedOf](10-isComposedOf.ts)
+
+Vérifier qu'une chaîne ne contient que des caractères appartenant à une ou plusieurs plages.
+ 
+### [DString.isEmail](10-isEmail.ts)
+
+Vérifier qu'une chaîne respecte le format d'une adresse e-mail.
+ 
+### [DString.isIn](10-isIn.ts)
+
+Vérifier qu'une chaîne appartient à une collection de valeurs autorisées.
+ 
+### [DString.isKeyof](10-isKeyof.ts)
+
+Vérifier qu'une valeur est une clé de l'objet fourni et affiner son type.
+ 
+### [DString.isNotEmpty](10-isNotEmpty.ts)
+
+Vérifier qu'une chaîne contient au moins un caractère.
+ 
+### [DString.isNumber](10-isNumber.ts)
+
+Vérifier qu'une chaîne représente un nombre et établir cette contrainte dans le type.
+ 
+### [DString.isTrimmed](10-isTrimmed.ts)
+
+Vérifier qu'une chaîne ne possède pas d'espace superflu à ses extrémités.
+ 
+### [DString.isUrl](10-isUrl.ts)
+
+Vérifier qu'une chaîne est une URL valide.
+ 
+### [DString.isUuid](10-isUuid.ts)
+
+Vérifier qu'une chaîne respecte le format UUID pris en charge.
+ 
+### [DString.join](10-join.ts)
+
+Réunir les chaînes d'une collection avec un séparateur.
+ 
+### [DString.last](10-last.ts)
+
+Lire le dernier caractère d'une chaîne.
+ 
+### [DString.lastIndexOf](10-lastIndexOf.ts)
+
+Retourner la dernière position d'une sous-chaîne, ou `undefined` si elle est absente.
+ 
+### [DString.length](10-length.ts)
+
+Retourner le nombre de caractères d'une chaîne.
+ 
+### [DString.lengthEqual](10-lengthEqual.ts)
+
+Tester ou établir qu'une chaîne possède exactement un nombre donné de caractères.
+ 
+### [DString.maxCharacters](10-maxCharacters.ts)
+
+Tester ou établir une longueur maximale pour une chaîne.
+ 
+### [DString.minCharacters](10-minCharacters.ts)
+
+Tester ou établir une longueur minimale pour une chaîne.
+ 
+### [DString.normalize](10-normalize.ts)
+
+Normaliser une chaîne selon une forme Unicode.
+ 
+### [DString.padEnd](10-padEnd.ts)
+
+Compléter une chaîne par la droite jusqu'à une longueur cible.
+ 
+### [DString.padStart](10-padStart.ts)
+
+Compléter une chaîne par la gauche jusqu'à une longueur cible.
+ 
+### [DString.pop](10-pop.ts)
+
+Retirer le dernier caractère d'une chaîne.
+ 
+### [DString.prepend](10-prepend.ts)
+
+Ajouter une ou plusieurs chaînes au début d'une chaîne.
+ 
+### [DString.repeat](10-repeat.ts)
+
+Répéter une chaîne un nombre positif de fois.
+ 
+### [DString.replace](10-replace.ts)
+
+Remplacer la première occurrence d'un motif par une chaîne ou une fonction de remplacement.
+ 
+### [DString.replaceAll](10-replaceAll.ts)
+
+Remplacer toutes les occurrences d'un motif par une chaîne ou une fonction de remplacement.
+ 
+### [DString.search](10-search.ts)
+
+Retourner la position d'un motif, ou `undefined` lorsqu'il ne correspond pas.
+ 
+### [DString.shift](10-shift.ts)
+
+Retirer le premier caractère d'une chaîne.
+ 
+### [DString.slice](10-slice.ts)
+
+Extraire une portion d'une chaîne entre deux index.
+ 
+### [DString.sort](10-sort.ts)
+
+Trier une copie d'une collection de chaînes dans l'ordre croissant ou décroissant.
+ 
+### [DString.sortCompare](10-sortCompare.ts)
+
+Comparer deux chaînes avec l'ordre de tri du domaine String.
+ 
+### [DString.split](10-split.ts)
+
+Découper une chaîne selon un séparateur, avec une limite facultative.
+ 
+### [DString.startsWith](10-startsWith.ts)
+
+Tester si une chaîne commence par une sous-chaîne.
+ 
+### [DString.stringify](10-stringify.ts)
+
+Convertir une valeur quelconque en représentation textuelle sans laisser `undefined` au résultat.
+ 
+### [DString.substring](10-substring.ts)
+
+Extraire une sous-chaîne selon les règles de `substring`.
+ 
+### [DString.test](10-test.ts)
+
+Tester une chaîne avec une expression régulière.
+ 
+### [DString.to](10-to.ts)
+
+Convertir une valeur stringifiable en chaîne en conservant les littéraux connus lorsque c'est possible.
+ 
+### [DString.toLowerCase](10-toLowerCase.ts)
+
+Convertir une chaîne en minuscules.
+ 
+### [DString.toUpperCase](10-toUpperCase.ts)
+
+Convertir une chaîne en majuscules.
+ 
+### [DString.trim](10-trim.ts)
+
+Supprimer les espaces au début et à la fin d'une chaîne.
+ 
+### [DString.trimEnd](10-trimEnd.ts)
+
+Supprimer les espaces à la fin d'une chaîne.
+ 
+### [DString.trimStart](10-trimStart.ts)
+
+Supprimer les espaces au début d'une chaîne.
+ 
+### [DString.uncapitalize](10-uncapitalize.ts)
+
+Mettre en minuscule le premier caractère d'une chaîne.
+ 

package/docs/API/10-lang/10-string/index.md

@@ -0,0 +1,3 @@
+## DString
+
+Fonctions de manipulation, recherche, validation et transformation des chaînes de caractères, avec des formes curifiées et des contraintes de typage lorsque l'API peut les établir.

package/docs/API/10-lang/10-tuple/10-from.ts

@@ -0,0 +1,50 @@
+/**
+ * @title DTuple.from
+ *
+ * Interpréter les contraintes de cardinalité d’un tableau comme une forme tuple.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DTuple from "@duplojs/lang/tuple";
+
+// Sans contrainte de cardinalité, la source reste un tableau de longueur inconnue.
+declare const values: readonly string[];
+const array = DTuple.from(values);
+type _CheckArray = DCommon.ExpectType<typeof array, readonly string[], "strict">;
+
+// Une longueur exacte établit le nombre de positions du tuple.
+declare const fixedValues: readonly string[] & DArray.LengthEqual<3>;
+const fixedTuple = DTuple.from(fixedValues);
+type _CheckFixedTuple = DCommon.ExpectType<
+	typeof fixedTuple,
+	readonly [string, string, string],
+	"strict"
+>;
+
+// Un minimum d’éléments garantit les premières positions et laisse la suite variable.
+declare const nonEmptyValues: readonly string[] & DArray.MinElements<2>;
+const nonEmptyTuple = DTuple.from(nonEmptyValues);
+type _CheckNonEmptyTuple = DCommon.ExpectType<
+	typeof nonEmptyTuple,
+	readonly [string, string, ...string[]],
+	"strict"
+>;
+
+// Ces conversions sont statiques : à l’exécution, from renvoie la même source.
+
+// Borne maximale seule : elle ne garantit aucune position présente.
+declare const boundedValues: readonly string[] & DArray.MaxElements<4>;
+const bounded = DTuple.from(boundedValues);
+// La source et sa contrainte restent inchangées.
+type _CheckBounded = DCommon.ExpectType<typeof bounded, readonly string[] & DArray.MaxElements<4>, "strict">;
+
+// Combinaison : les positions minimales et la borne maximale sont conservées.
+declare const rangedValues: readonly string[] & DArray.MinElements<2> & DArray.MaxElements<4>;
+const ranged = DTuple.from(rangedValues);
+type _CheckRanged = DCommon.ExpectType<typeof ranged, readonly [string, string, ...string[]] & DArray.MaxElements<4>, "strict">;
+
+// Un tuple déjà précis est reconstruit à partir de son union d’éléments.
+declare const pair: readonly ["name", 1];
+const rebuilt = DTuple.from(pair);
+// Même valeur et même référence, mais les types propres à chaque position sont perdus.
+type _CheckRebuilt = DCommon.ExpectType<typeof rebuilt, readonly [1 | "name", 1 | "name"], "strict">;

package/docs/API/10-lang/10-tuple/10-map.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DTuple.map
+ *
+ * Transformer chaque élément d’un tuple en conservant sa cardinalité.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+import * as DTuple from "@duplojs/lang/tuple";
+
+// L’index de chaque élément est disponible dans le contexte du callback.
+const positions = DTuple.map(
+	["draft", "ready"],
+	(_value, { index }) => index,
+);
+// La valeur obtenue est [0, 1].
+type _CheckPositions = DCommon.ExpectType<typeof positions, readonly [number, number], "strict">;
+
+// La forme curifiée transforme les éléments dans un pipe, avant de les réunir.
+declare const states: readonly ["draft", "ready"];
+const key = DCommon.pipe(
+	states,
+	DTuple.map(DString.toUpperCase),
+	DString.join("-"),
+);
+// La valeur obtenue est "DRAFT-READY".
+// Le type conservateur combine toutes les chaînes produites pour chaque position.
+type _CheckKey = DCommon.ExpectType<
+	typeof key,
+	"DRAFT-DRAFT" | "DRAFT-READY" | "READY-DRAFT" | "READY-READY",
+	"strict"
+>;
+
+// Tuple à reste variable : le premier élément reste garanti après transformation.
+declare const names: readonly [string, ...string[]];
+const upperNames = DTuple.map(names, DString.toUpperCase);
+// Chaque nom est converti en majuscules ; au moins une position est conservée.
+type _CheckUpperNames = DCommon.ExpectType<typeof upperNames, readonly [Uppercase<string>, ...Uppercase<string>[]], "strict">;

package/docs/API/10-lang/10-tuple/index.llms.md

@@ -0,0 +1,12 @@
+## DTuple
+
+Manipulation et typage des tuples : convertir les garanties de cardinalité en positions typées, puis transformer leurs éléments en conservant leur forme.
+
+### [DTuple.from](10-from.ts)
+
+Interpréter les contraintes de cardinalité d’un tableau comme une forme tuple.
+ 
+### [DTuple.map](10-map.ts)
+
+Transformer chaque élément d’un tuple en conservant sa cardinalité.
+ 

package/docs/API/10-lang/10-tuple/index.md

@@ -0,0 +1,3 @@
+## DTuple
+
+Manipulation et typage des tuples : convertir les garanties de cardinalité en positions typées, puis transformer leurs éléments en conservant leur forme.

package/docs/API/10-lang/index.md

@@ -0,0 +1,3 @@
+# @duplojs/lang
+
+Primitives fonctionnelles indépendantes de la plateforme pour composer des transformations, manipuler les données et préserver leurs garanties de typage.

package/docs/API/40-json-web-token/10-tokenHandler/10-createTokenHandler.ts

@@ -0,0 +1,160 @@
+/**
+ * @title createTokenHandler
+ *
+ * Construire une politique JWT typée et réutilisable.
+ */
+import { Cipher, createTokenHandler, Signer } from "@duplojs/json-web-token";
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+
+// Secret fourni par l'environnement ; choisir une clé adaptée à la production.
+declare const secret: string;
+
+const sessions = createTokenHandler({
+	maxAge: DChrono.createTime(15, "minute"),
+	issuer: "application",
+	audience: "api",
+	subject: "session",
+
+	signer: Signer.createHS256({
+		secret,
+	}),
+
+	customPayloadShape: {
+		userId: DDataStructure.string(),
+		role: DDataStructure.literal("admin"),
+	},
+	customHeaderShape: {
+		kid: DDataStructure.string(),
+	},
+});
+
+const creation = await sessions.create(
+	{
+		userId: "42",
+		role: "admin",
+	},
+	{
+		header: {
+			kid: "current",
+		},
+	},
+);
+
+if (DEither.isRight(creation)) {
+	const token = DEither.unwrapRight(creation);
+	const verification = await sessions.verify(token);
+
+	if (DEither.isRight(verification)) {
+		// La signature et les contrôles de politique ont réussi.
+		const { header, payload } = DEither.unwrapRight(verification);
+		const userId = payload.userId;
+
+		type _Role = DCommon.ExpectType<
+			typeof payload.role,
+			"admin",
+			"strict"
+		>;
+		type _Algorithm = DCommon.ExpectType<
+			typeof header.alg,
+			"HS256",
+			"strict"
+		>;
+		type _KeyId = DCommon.ExpectType<
+			typeof header.kid,
+			string,
+			"strict"
+		>;
+	}
+	// Un Left identifie le refus : signature-invalid, expired ou autre motif.
+
+	// decode valide les structures, mais pas la signature ni la politique.
+	// Son résultat typé ne prouve donc pas l'identité de l'émetteur.
+	const decoded = await sessions.decode(token);
+	if (DEither.isRight(decoded)) {
+		// La structure est validée, sans authentifier ces données.
+		const decodedPayload = DEither.unwrapRight(decoded).payload;
+	}
+}
+
+// create renvoie notamment des Left d'encodage ; verify peut aussi renvoyer
+// signature-invalid, issue-invalid, subject-invalid, audience-invalid ou expired.
+// createOrThrow renvoie directement le token ou lève TokenHandlerCreateError.
+const token = await sessions.createOrThrow(
+	{
+		userId: "42",
+		role: "admin",
+	},
+	{
+		header: {
+			kid: "current",
+		},
+	},
+);
+
+// Une factory reporte la configuration du signer à chaque opération concernée.
+const dynamicSessions = createTokenHandler({
+	maxAge: DChrono.createTime(15, "minute"),
+	signer: Signer.createHS256,
+	customPayloadShape: {
+		userId: DDataStructure.string(),
+	},
+});
+
+const dynamicCreation = await dynamicSessions.create(
+	{ userId: "42" },
+	{ signer: { secret } },
+);
+if (DEither.isRight(dynamicCreation)) {
+	const dynamicToken = DEither.unwrapRight(dynamicCreation);
+	// Either : token vérifié ou motif de refus.
+	const verification = await dynamicSessions.verify(
+		dynamicToken,
+		{ signer: { secret } },
+	);
+}
+
+// Les shapes valident des champs, sans enregistrer de règles de politique personnalisées.
+// Un cipher facultatif chiffre le token entier ; decode et verify le déchiffrent.
+// Avec une factory de chiffrement, seules les opérations concernées reçoivent
+// ses clés : decode ne requiert pas de paramètres de signature.
+// RSA-OAEP limite la taille du texte chiffrable selon la clé et le hash :
+// vérifier que le token signé tient dans cette limite avant de choisir ce cipher.
+declare const privateKey: string;
+declare const publicKey: string;
+
+const encryptedSessions = createTokenHandler({
+	maxAge: DChrono.createTime(15, "minute"),
+	signer: Signer.createHS256({
+		secret,
+	}),
+	cipher: Cipher.createRSAOAEP256,
+	customPayloadShape: {
+		userId: DDataStructure.string(),
+	},
+});
+
+const encryptedCreation = await encryptedSessions.create(
+	{ userId: "42" },
+	{
+		cipher: {
+			privateKey,
+			publicKey,
+		},
+	},
+);
+if (DEither.isRight(encryptedCreation)) {
+	const encryptedToken = DEither.unwrapRight(encryptedCreation);
+	// Either contenant les données décodées ou un refus de structure.
+	const decoded = await encryptedSessions.decode(
+		encryptedToken,
+		{
+			cipher: {
+				privateKey,
+				publicKey,
+			},
+		},
+	);
+}

package/docs/API/40-json-web-token/10-tokenHandler/index.llms.md

@@ -0,0 +1,8 @@
+## TokenHandler
+
+Définir une politique et créer, décoder ou vérifier les tokens associés.
+
+### [createTokenHandler](10-createTokenHandler.ts)
+
+Construire une politique JWT typée et réutilisable.
+ 

package/docs/API/40-json-web-token/10-tokenHandler/index.md

@@ -0,0 +1,3 @@
+## TokenHandler
+
+Définir une politique et créer, décoder ou vérifier les tokens associés.