Il y a plusieurs types de "typage fort":

• typage strict: absence de conversions implicites. Il y a plusieurs niveaux là: style VB, JS ou PHP où il y a même des conversions implicites entre chaînes de caractères et nombres; style C où ce n'est qu'entre nombres; style Pascal où il faut déjà une conversion explicite entre entiers et flottants; style Ada où tout doit être explicitement converti.
• typage statique: assignation d'un type fixe à une variable à l'avance, généralement lors de la compilation. Là aussi, il y a un niveau intermédiaire entre le typage statique totalement type-safe et le typage entièrement dynamique: un typage statique où tu as des types génériques non-type-safe, du moins à la compilation (void* en C, les divers types variant (par exemple QVariant en C++/Qt, le Variant de VB etc.), Object en Java, …). Certains sont totalement unsafe (aucune vérification, par exemple void*), d'autres ont au moins un typage dynamique type-safe (variants, Object de Java). Rares sont les langages où il n'y a vraiment que des types statiques, parce qu'il y a des cas où ce n'est vraiment pas pratique.
• typage explicite: absence d'inférence. Le problème de l'inférence est que tu ne contrôles pas directement le type assigné et qu'il n'est pas forcément celui que tu attends, ce qui peut être source d'erreurs. Donc il y a des erreurs que le typage statique explicite reconnaîtrait que le typage statique implicite par inférence laisse passer, en assignant silencieusement le "mauvais" type.

Un typage totalement "faible" n'existe pas parce qu'il faut faire un compromis entre typage laxiste (non-strict) et typage implicite (inférence), parce que tu ne peux pas convertir implicitement si tu ne sais pas en quoi convertir, tu dois forcément soit mettre une conversion explicite pour faire marcher l'inférence, soit déclarer un type explicite pour faire marcher la conversion automatique. Un typage totalement "fort" serait possible en principe, mais en pratique tu trouveras toujours des compromis.

[EDIT: orthographe]