Donating EL Translations

java/jakarta/el/LocalStrings.properties

@@ -50,3 +50,4 @@ staticFieldELResolver.notWritable=Writing to static fields (in this case field [
 
 util.method.ambiguous=Unable to find unambiguous method: {0}.{1}({2})
 util.method.notfound=Method not found: {0}.{1}({2})
+

java/jakarta/el/LocalStrings_cs.properties

@@ -13,8 +13,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-elProcessor.defineFunctionInvalidMethod=Metoda [{0}] třídy [{1}] není public static metoda
+beanNameELResolver.beanReadOnly=Název objektu typu bean [{0}] jen pro čtení
+
+elProcessor.defineFunctionInvalidClass=Třída [{0}] není veřejná
+elProcessor.defineFunctionInvalidMethod=Metoda [{0}] na třídě [{1}] není veřejnou statickou metodou
+elProcessor.defineFunctionInvalidParameterList=Seznam parametrů [{0}] pro metodu [{1}] na třídě [{2}] není platný
+elProcessor.defineFunctionInvalidParameterTypeName=Typ parametru [{0}] pro metodu [{1}] na třídě [{2}] není platný
+elProcessor.defineFunctionNoMethod=Veřejnou statickou metodu [{0}] pro třídu [{1}] nelze nalézt
+elProcessor.defineFunctionNullParams=Nejméně jeden ze vstupních parametrů byl null
+
+expressionFactory.cannotCreate=Nelze vytvořit ExpressionFactory typu [{0}]
+expressionFactory.cannotFind=Nelze najít ExpressionFactory typu [{0}]
+expressionFactory.readFailed=Nezdařilo se přečíst [{0}]
+
+importHandler.ambiguousImport=Třídu [{0}] nelze importovat, protože je v konfliktu s [{1}], který již byl importován
+importHandler.ambiguousStaticImport=Statický import [{0}] nelze zpracovat, protože je v konfliktu s [{1}], který již byl importován
+importHandler.classNotFound=Třídu [{0}] nelze importovat, protože ji nelze nalézt
+importHandler.invalidClass=Třída [{0}] musí být veřejná, v exportovaném balíku (pro Java 9+), neabstraktní a nesmí být rozhraním
+importHandler.invalidClassName=Název třídy pro import [{0}] musí obsahovat balík
+importHandler.invalidClassNameForStatic=Třída [{0}] určená pro statický import [{1}] není platná
+importHandler.invalidStaticName=Název statické metody nebo pole pro import [{0}] musí obsahovat třídu
+importHandler.staticNotFound=Statický import [{0}] nebyl nalezen ve třídě [{1}] pro import [{2}]
+
+lambdaExpression.tooFewArgs=Pouze [{0}] argumentů bylo poskytnuto pro výraz lambda, který vyžaduje alespoň [{1}]
+
+objectNotAssignable=Nelze přidat objekt typu [{0}] do pole objektů typu [{1}].
+propertyNotFound=Vlastnost [{1}] nebyla nalezena u typu [{0}]
+propertyNotReadable=Vlastnost [{1}] není čitelná u typu [{0}]
+propertyNotWritable=Vlastnost [{1}] není zapisovatelná u typu [{0}]
+propertyReadError=Chyba při čtení [{1}] u typu [{0}]
+propertyWriteError=Chyba pri zápisu [{1}] u typu [{0}]
+
+staticFieldELResolver.methodNotFound=Nebyla nalezena žádná odpovídající veřejná statická metoda s názvem [{0}] ve třídě [{1}]
+staticFieldELResolver.notFound=Nebylo nalezeno žádné veřejné statické pole s názvem [{0}] ve třídě [{1}] (exportované pro Java 9+)
+staticFieldELResolver.notWritable=Zápis do statických polí (v tomto případě pole [{0}] pro třídu [{1}]) není povolen
+
+util.method.ambiguous=Nelze najít jednoznačnou metodu: {0}.{1}({2})
+util.method.notfound=Metoda nebyla nalezena: {0}.{1}({2})
 
-importHandler.ambiguousStaticImport=Statický import [{0}] nelze zpracovat, neboť koliduje s [{1}] (který byl již naimportován)
-importHandler.classNotFound=Třídu [{0}] nelze naimportovat, neboť nebyla nalezena
-importHandler.invalidClassNameForStatic=Třída [{0}] uvedená pro statický import [{1}] není platná

java/jakarta/el/LocalStrings_de.properties

@@ -13,10 +13,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-elProcessor.defineFunctionInvalidClass=Die Klasse [{0}] ist nicht öffentlich
-elProcessor.defineFunctionInvalidMethod=Die Methode [{0}] der Klasse [{1}] ist nicht public static
+beanNameELResolver.beanReadOnly=Der Beanname [{0}] ist schreibgeschützt.
 
-expressionFactory.cannotFind=Kann die ExpressionFactory mit dem Typ [{0}] nicht finden
+elProcessor.defineFunctionInvalidClass=Die Klasse [{0}] ist nicht öffentlich.
+elProcessor.defineFunctionInvalidMethod=Die Methode [{0}] in der Klasse [{1}] ist keine öffentliche statische Methode.
+elProcessor.defineFunctionInvalidParameterList=Die Parameterliste [{0}] für die Methode [{1}] in der Klasse [{2}] ist nicht gültig.
+elProcessor.defineFunctionInvalidParameterTypeName=Der Parametertyp [{0}] für die Methode [{1}] in der Klasse [{2}] ist nicht gültig.
+elProcessor.defineFunctionNoMethod=Es wurde keine öffentliche statische Methode [{0}] in der Klasse [{1}] gefunden.
+elProcessor.defineFunctionNullParams=Mindestens einer der Eingabeparameter ist null.
+
+expressionFactory.cannotCreate=Die Ausdruckfactory vom Typ [{0}] konnte nicht erstellt werden.
+expressionFactory.cannotFind=Die Ausdruckfactory vom Typ [{0}] konnte nicht gefunden werden.
+expressionFactory.readFailed=Fehler beim Lesen von [{0}]
+
+importHandler.ambiguousImport=Die Klasse {0}] konnte nicht importiert werden, weil sie mit dem bereits durchgeführten Import von [{1}] in Konflikt steht.
+importHandler.ambiguousStaticImport=Der statische Import [{0}] konnte nicht verarbeitet werden, weil er mit dem bereits durchgeführten Import von [{1}] in Konflikt steht.
+importHandler.classNotFound=Die Klasse [{0}] konnte nicht importiert werden, weil sie nicht gefunden wurde.
+importHandler.invalidClass=Die Klasse [{0}] muss eine öffentliche, in einem exportierten Paket (für Java 9+), nicht abstrakte Klasse und darf keine Schnittstelle sein.
+importHandler.invalidClassName=Der Name der zu importierenden Klasse [{0}] muss ein Paket enthalten.
+importHandler.invalidClassNameForStatic=Die Klasse [{0}], die für den statischen Import [{1}] angegeben wurde, ist nicht gültig.
+importHandler.invalidStaticName=Der Name der zu importierenden statischen Methode bzw. des zu importierenden Felds [{0}] muss eine Klasse enthalten.
+importHandler.staticNotFound=Der statische Import [{0}] wurde nicht in der Klasse [{1}] für den Import [{2}] gefunden.
+
+lambdaExpression.tooFewArgs=Es wurden nur [{0}] Argumente für einen Lambdaausdruck angegeben, der mindestens [{1}] Argumente erfordert.
+
+objectNotAssignable=Ein Objekt des Typs [{0}] kann keinem Array von Objekten des Typs [{1}] hinzugefügt werden.
+propertyNotFound=Die Eigenschaft [{1}] wurde für den Typ [{0}] nicht gefunden
+propertyNotReadable=Die Eigenschaft [{1}] ist für den Typ [{0}] nicht lesbar
+propertyNotWritable=Die Eigenschaft [{1}] kann nicht für den Typ [{0}] beschrieben werden
+propertyReadError=Fehler beim Lesen von [{1}] für den Typ [{0}]
+propertyWriteError=Fehler beim Schreiben von [{1}] für den Typ [{0}]
+
+staticFieldELResolver.methodNotFound=Es wurde keine öffentliche statische Methode mit dem Namen [{0}] in der Klasse [{1}] gefunden.
+staticFieldELResolver.notFound=Es wurde kein öffentliches statisches Feld mit dem Namen [{0}] in der (für Java 9+ exportierten) Klasse [{1}] gefunden.
+staticFieldELResolver.notWritable=Das Schreiben in statische Felder (in diesem Fall Feld [{0}] in Klasse [{1}]) ist nicht zulässig.
+
+util.method.ambiguous=Es wurde keine eindeutige Methode gefunden: {0}.{1}({2})
+util.method.notfound=Methode nicht gefunden: {0}.{1}({2})
 
-importHandler.classNotFound=Die Klasse [{0}] konnte nicht importiert werden, da sie nicht gefunden werden konnte
-importHandler.invalidClassNameForStatic=Ungültige Klasse [{0}] für angegebenen static import [{1}]

java/jakarta/el/LocalStrings_es.properties

@@ -13,16 +13,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+beanNameELResolver.beanReadOnly=El nombre de bean [{0}] es de sólo lectura
+
+elProcessor.defineFunctionInvalidClass=La clase [{0}] no es pública
 elProcessor.defineFunctionInvalidMethod=El método [{0}] en la clase [{1}] no es un método estático público
+elProcessor.defineFunctionInvalidParameterList=La lista de parámetros [{0}] para el método [{1}] en la clase [{2}] no es válida
+elProcessor.defineFunctionInvalidParameterTypeName=El tipo de parámetro [{0}] para el método [{1}] en la clase [{2}] no es válido
+elProcessor.defineFunctionNoMethod=No se ha podido encontrar un método estático público [{0}] en la clase [{1}]
+elProcessor.defineFunctionNullParams=Uno o varios de los parámetros de entrada era nulo
+
+expressionFactory.cannotCreate=No se ha podido crear un ExpressionFactory de tipo [{0}]
+expressionFactory.cannotFind=No se ha podido encontrar un ExpressionFactory de tipo [{0}]
+expressionFactory.readFailed=No se ha podido leer [{0}]
+
+importHandler.ambiguousImport=La clase [{0}] no se ha podido importar ya que está en conflicto con [{1}], que ya se ha importado
+importHandler.ambiguousStaticImport=No se ha podido procesar la importación estática [{0}] ya que está en conflicto con [{1}] que ya se ha importado
+importHandler.classNotFound=No se ha podido importar la clase [{0}], ya que no se ha podido importar
+importHandler.invalidClass=La clase [{0}] debe ser pública, estar en un paquete exportado (para Java 9+), ser no abstracta y no ser una interfaz
+importHandler.invalidClassName=El nombre de la clase para importar [{0}] debe incluir un paquete
+importHandler.invalidClassNameForStatic=La clase [{0}] especificada para la importación estática [{1}] no es válida
+importHandler.invalidStaticName=El nombre del campo o método estático para importar [{0}] debe incluir una clase
+importHandler.staticNotFound=No se ha podido encontrar la importación estática [{0}] en la clase [{1}] para la importación [{2}]
+
+lambdaExpression.tooFewArgs=Sólo se han proporcionado [{0}] argumentos para una expresión lambda que requiere al menos [{1}]
+
+objectNotAssignable=No se puede añadir un objeto de tipo [{0}] a una matriz de objetos de tipo [{1}]
+propertyNotFound=No se ha encontrado la propiedad [{1}] en el tipo [{0}]
+propertyNotReadable=La propiedad [{1}] no se puede leer en el tipo [{0}]
+propertyNotWritable=La propiedad [{1}] no se puede escribir en el tipo [{0}]
+propertyReadError=Error al leer [{1}] en el tipo [{0}]
+propertyWriteError=Error al escribir [{1}] en el tipo [{0}]
+
+staticFieldELResolver.methodNotFound=No se ha encontrado ningún método estático público coincidente denominado [{0}] en la clase [{1}]
+staticFieldELResolver.notFound=No se ha encontrado ningún campo estático público denominado [{0}] en la clase [{1}] (exportada para Java 9+)
+staticFieldELResolver.notWritable=No se permite escribir en campos estáticos (en este caso, el campo [{0}] en la clase [{1}])
+
+util.method.ambiguous=No se ha podido encontrar el método no ambiguo: {0}.{1}({2})
+util.method.notfound=No se ha encontrado el método: {0}.{1}({2})
 
-importHandler.ambiguousStaticImport=La importación estática [{0}] no puede ser procesada pues entra en conflicto con [{1}] la cual ya ha sido importada
-importHandler.classNotFound=La clase [{0}] no puede ser importada debido a que no fué encontrada
-importHandler.invalidClassNameForStatic=La clase [{0}] especificada para importación estática  [{1}] no es valida
-importHandler.staticNotFound=La importación estática [{0}] no se pudo encontrar en la clase [{1}] para importar [{2}]
-
-objectNotAssignable=No puedo añadir un objeto del tipo [{0}] a un arreglo de objetos del tipo [{1}]
-propertyNotFound=Propiedad [{1}] no hallada en el tipo [{0}]
-propertyNotReadable=Propiedad [{1}] no legible para el tipo [{0}]
-propertyNotWritable=Propiedad [{1}] no grabable para el tipo [{0}]
-propertyReadError=Error reading [{1}] en el tipo [{0}]
-propertyWriteError=Error writing [{1}] en el tipo [{0}]

java/jakarta/el/LocalStrings_fr.properties

@@ -17,36 +17,37 @@ beanNameELResolver.beanReadOnly=Le nom de bean [{0}] est en lecture seule
 
 elProcessor.defineFunctionInvalidClass=La classe [{0}] n''est pas publique
 elProcessor.defineFunctionInvalidMethod=La méthode [{0}] sur la classe [{1}] n''est pas une méthode statique publique
-elProcessor.defineFunctionInvalidParameterList=La liste de paramètres [{0}] pour la méthode [{1}] de la classe [{2}] n''est pas valide
-elProcessor.defineFunctionInvalidParameterTypeName=Le type [{0}] du paramètre de la méthode [{1}] sur la classe [{2}] n''est pas valide
-elProcessor.defineFunctionNoMethod=Une méthode statique et publique [{0}] n''a pas pu être trouvée sur la classe [{1}]
-elProcessor.defineFunctionNullParams=On ou plusieurs paramètres d'entrée sont null
-
-expressionFactory.cannotCreate=Impossible de créer une ExpressionFactory de type [{0}]
-expressionFactory.cannotFind=Impossible de trouver une ExpressionFactory de type [{0}]
-expressionFactory.readFailed=Impossible de lire [{0}]
-
-importHandler.ambiguousImport=La classe [{0}] n''a pas pu être importée car elle entre en conflit avec [{1}] qui a déjà été importée
-importHandler.ambiguousStaticImport=L''import statique [{0}] ne peut pas être traité parce qu''il est en conflit avec [{1}] qui a déjà été importé
-importHandler.classNotFound=La classe [{0}] n''a pu être importée, vu qu''on ne l''a pas trouvée
-importHandler.invalidClass=La classe [{0}] doit être publique, non abstraite, ne pas être une interface et (pour Java 9+) être dans un package exporté
-importHandler.invalidClassName=Le nom de la classe à importer [{0}] doit comprendre un paquet
-importHandler.invalidClassNameForStatic=La classe [{0}] spécifiée pour l''import statique [{1}] n''est pas valide
-importHandler.invalidStaticName=Le nom de la méthode statique ou champ à importer [{0}] doit inclure une calsse
-importHandler.staticNotFound=L''importation statique [{0}] n''a pas été trouvée dans la classe [{1}] pour [{2}]
-
-lambdaExpression.tooFewArgs=Seuls [{0}] arguments ont été fournis pour une expression lambda qui en demande au moins [{1}]
-
-objectNotAssignable=Impossible d''ajouter un objet du type [{0}] à un tableau d''objets de type [{1}]
-propertyNotFound=La propriété [{1}] n''a pas été trouvée sur le type [{0}]
-propertyNotReadable=La propriété [{1}] n''est pas lisible sur le type [{0}]
-propertyNotWritable=La propriété [{1}] ne peut pas être écrite pour le type [{0}]
-propertyReadError=Erreur lors de la lecture de [{1}] sur le type [{0}]
-propertyWriteError=Erreur d''écriture [{1}] sur le type [{0}]
-
-staticFieldELResolver.methodNotFound=Aucune méthode publique et statique nommée [{0}] n''a été trouvée dans la classe [{1}]
-staticFieldELResolver.notFound=Aucun champ public statique nommé [{0}] n''a été trouvé dans la classe [{1}] (exportée pour Java 9+)
-staticFieldELResolver.notWritable=L''écriture dans les champs statiques (champ [{0}] dans la classe [{1}] dans le cas présent) est interdite
-
-util.method.ambiguous=Impossible de trouver une méthode non ambiguë : {0}.{1}({2})
+elProcessor.defineFunctionInvalidParameterList=La liste de paramètres [{0}] pour la méthode [{1}] sur la classe [{2}] n''est pas valide
+elProcessor.defineFunctionInvalidParameterTypeName=Le type de paramètre [{0}] pour la méthode [{1}] sur la classe [{2}] n''est pas valide
+elProcessor.defineFunctionNoMethod=Une méthode statique publique [{0}] sur la classe [{1}] est introuvable
+elProcessor.defineFunctionNullParams=Un ou plusieurs des paramètres en entrée avaient une valeur nulle
+
+expressionFactory.cannotCreate=Impossible de créer ExpressionFactory de type [{0}]
+expressionFactory.cannotFind=Impossible de trouver ExpressionFactory de type [{0}]
+expressionFactory.readFailed=Echec de lecture de [{0}]
+
+importHandler.ambiguousImport=.La classe [{0}] n''a pas pu être importée car elle est en conflit avec [{1}] qui est déjà importé
+importHandler.ambiguousStaticImport=L''importation statique [{0}] n''a pas pu être traitée car elle est en conflit avec [{1}] qui est déjà importé
+importHandler.classNotFound=La classe [{0}] n''a pas pu être importée car elle est introuvable
+importHandler.invalidClass=La classe [{0}] doit être publique, dans un package exporté (pour Java 9+), non abstraite et ne doit pas être une interface
+importHandler.invalidClassName=Le nom de la classe à importer [{0}] doit inclure un package
+importHandler.invalidClassNameForStatic=La classe [{0}] spécifiée pour l''importation statique [{1}] n''est pas valide
+importHandler.invalidStaticName=Le nom de la méthode ou de la zone statique à importer [{0}] doit inclure une classe
+importHandler.staticNotFound=L''importation statique [{0}] est introuvable dans la classe [{1}] pour l''importation [{2}]
+
+lambdaExpression.tooFewArgs=Seuls [{0}] arguments ont été fournis pour une expression lambda qui en requiert au moins [{1}]
+
+objectNotAssignable=Impossible d''ajouter un objet de type [{0}] à un tableau d''objets de type [{1}]
+propertyNotFound=Propriété [{1}] introuvable sur le type [{0}]
+propertyNotReadable=Propriété [{1}] illisible sur le type [{0}]
+propertyNotWritable=Propriété [{1}] non inscriptible sur le type [{0}]
+propertyReadError=Erreur de lecture de [{1}] sur le type [{0}]
+propertyWriteError=Erreur d''écriture de [{1}] sur le type [{0}]
+
+staticFieldELResolver.methodNotFound=Aucune méthode statique publique nommée [{0}] n''a été détectée sur la classe [{1}]
+staticFieldELResolver.notFound=Aucune zone statique publique nommée [{0}] n''a été détectée sur la classe (exportée pour Java 9+) [{1}]
+staticFieldELResolver.notWritable=L''écriture dans les zones statiques (dans ce cas la zone [{0}] sur la classe [{1}]) n''est pas autorisée
+
+util.method.ambiguous=Méthode non ambiguë : {0}.{1}({2}) non trouvée
 util.method.notfound=Méthode non trouvée : {0}.{1}({2})
+