diff --git a/README.md b/README.md
index 38c144c..a202a2a 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,18 @@ pxt.json file:
 }
 ```
 
+## Translations
+
+We manage translations via Crowdin.
+
+#### Incorporting changes from Crowdin
+
+Use [update-translations.sh](./bin/update-translations.sh).
+
+Build and download the Crowdin zip and unzip it to a temporary location. Note the zip itself doesn't contain a top-level directory, so on Mac/Linux use e.g. `unzip -d ~/tmp/trans microbit-org.zip`. Run the script passing the directory containing the unzipped translations.
+
+The script will update the extension UI and sim strings.
+
 ## License
 
 This software made available under the MIT open source license.
diff --git a/_locales/es-ES/machine-learning-jsdoc-strings.json b/_locales/es-ES/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..1d807c3
--- /dev/null
+++ b/_locales/es-ES/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "Obtiene la certeza de un evento ML en porcentaje (0 a 100).",
+  "ml.getCertainty|param|event": "una de las acciones con las que el modelo de aprendizaje automático fue entrenado",
+  "ml.isDetected": "Comprueba si se ha detectado un evento ML.",
+  "ml.isDetected|param|event": "una de las acciones con las que el modelo de aprendizaje automático fue entrenado",
+  "ml.onStart": "Hace algo cuando se detecta un evento ML.",
+  "ml.onStart|param|body": "código a ejecutar",
+  "ml.onStart|param|event": "una de las acciones con las que el modelo de aprendizaje automático fue entrenado",
+  "ml.onStop": "Hace algo cuando ya no se detecta un evento ML.",
+  "ml.onStopDetailed": "Hace algo cuando ya no se detecta un evento ML.",
+  "ml.onStopDetailed|param|body": "código a ejecutar",
+  "ml.onStopDetailed|param|event": "una de las acciones con las que el modelo de aprendizaje automático fue entrenado",
+  "ml.onStop|param|body": "código a ejecutar",
+  "ml.onStop|param|event": "una de las acciones con las que el modelo de aprendizaje automático fue entrenado"
+}
\ No newline at end of file
diff --git a/_locales/es-ES/machine-learning-strings.json b/_locales/es-ES/machine-learning-strings.json
new file mode 100644
index 0000000..c939c34
--- /dev/null
+++ b/_locales/es-ES/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "desconocido",
+  "ml.getCertainty|block": "certeza (\\%) ML $event",
+  "ml.isDetected|block": "se ha detectado ML $event",
+  "ml.onStart|block": "al iniciar ML $event",
+  "ml.onStopDetailed|block": "en ML $event parada $duration (ms)",
+  "ml.onStop|block": "en parada ML $event ",
+  "ml|block": "Aprendizaje Automático",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/ja/machine-learning-jsdoc-strings.json b/_locales/ja/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..4f70f6b
--- /dev/null
+++ b/_locales/ja/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "ML イベントの確実性をパーセント (0 ～ 100) で取得します。",
+  "ml.getCertainty|param|event": "機械学習モデルが訓練された動きの１つ",
+  "ml.isDetected": "MLイベントが現在検出されたかのテスト",
+  "ml.isDetected|param|event": "機械学習モデルが訓練された動きの１つ",
+  "ml.onStart": "MLイベントが検出されたときに何かを行います。",
+  "ml.onStart|param|body": "実行するプログラム",
+  "ml.onStart|param|event": "機械学習モデルが訓練された動きの１つ",
+  "ml.onStop": "MLイベントが検出されなくなったときに何かを行います。",
+  "ml.onStopDetailed": "MLイベントが検出されなくなったときに何かを行います。",
+  "ml.onStopDetailed|param|body": "実行するプログラム",
+  "ml.onStopDetailed|param|event": "機械学習モデルが訓練された動きの１つ",
+  "ml.onStop|param|body": "実行するプログラム",
+  "ml.onStop|param|event": "機械学習モデルが訓練された動きの１つ"
+}
\ No newline at end of file
diff --git a/_locales/ja/machine-learning-strings.json b/_locales/ja/machine-learning-strings.json
new file mode 100644
index 0000000..4c4080a
--- /dev/null
+++ b/_locales/ja/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "不明",
+  "ml.getCertainty|block": "確実性(\\%) ML $event",
+  "ml.isDetected|block": "ML が $event を検出したとき",
+  "ml.onStart|block": "ML の $event が開始したとき",
+  "ml.onStopDetailed|block": "ML $event を $duration (ms)停止",
+  "ml.onStop|block": "ML $event が停止したとき",
+  "ml|block": "機械学習",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/ko/machine-learning-jsdoc-strings.json b/_locales/ko/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..e4bba1b
--- /dev/null
+++ b/_locales/ko/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "ML 이벤트의 확실성을 백분율(0~100)로 표시합니다.",
+  "ml.getCertainty|param|event": "기계 학습 모델이 학습한 행동 중 하나",
+  "ml.isDetected": "ML 이벤트가 현재 감지되는지 테스트합니다.",
+  "ml.isDetected|param|event": "기계 학습 모델이 학습한 행동 중 하나",
+  "ml.onStart": "ML 이벤트가 감지되면 무언가를 합니다.",
+  "ml.onStart|param|body": "실행할 코드",
+  "ml.onStart|param|event": "기계 학습 모델이 학습한 행동 중 하나",
+  "ml.onStop": "ML 이벤트가 더 이상 감지되지 않으면 무언가를 합니다.",
+  "ml.onStopDetailed": "ML 이벤트가 더 이상 감지되지 않으면 무언가를 합니다.",
+  "ml.onStopDetailed|param|body": "실행할 코드",
+  "ml.onStopDetailed|param|event": "기계 학습 모델이 학습한 행동 중 하나",
+  "ml.onStop|param|body": "실행할 코드",
+  "ml.onStop|param|event": "기계 학습 모델이 학습한 행동 중 하나"
+}
\ No newline at end of file
diff --git a/_locales/ko/machine-learning-strings.json b/_locales/ko/machine-learning-strings.json
new file mode 100644
index 0000000..a8c78f9
--- /dev/null
+++ b/_locales/ko/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "알 수 없음",
+  "ml.getCertainty|block": "확실성 (\\%) ML $event",
+  "ml.isDetected|block": "ML $event가 감지되었나요?",
+  "ml.onStart|block": "ML $event 시작 시",
+  "ml.onStopDetailed|block": "ML $event 중지 시 $duration(ms)",
+  "ml.onStop|block": "ML $event 중지 시",
+  "ml|block": "기계 학습",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/nl/machine-learning-jsdoc-strings.json b/_locales/nl/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..9bea0e5
--- /dev/null
+++ b/_locales/nl/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "Verkrijg de zekerheid van een ML-evenement in procenten (0 tot 100).",
+  "ml.getCertainty|param|event": "een van de acties waar het machine-learningmodel op is getraind",
+  "ml.isDetected": "Test of een ML-gebeurtenis momenteel is gedetecteerd.",
+  "ml.isDetected|param|event": "een van de acties waar het machine-learningmodel op is getraind",
+  "ml.onStart": "Doe iets wanneer een ML-gebeurtenis is gedetecteerd.",
+  "ml.onStart|param|body": "code om uit te voeren",
+  "ml.onStart|param|event": "een van de acties waar het machine-learningmodel op is getraind",
+  "ml.onStop": "Doe iets wanneer een ML-gebeurtenis niet meer wordt gedetecteerd.",
+  "ml.onStopDetailed": "Doe iets wanneer een ML-gebeurtenis niet meer wordt gedetecteerd.",
+  "ml.onStopDetailed|param|body": "code om uit te voeren",
+  "ml.onStopDetailed|param|event": "een van de acties waar het machine-learningmodel op is getraind",
+  "ml.onStop|param|body": "code om uit te voeren",
+  "ml.onStop|param|event": "een van de acties waar het machine-learningmodel op is getraind"
+}
\ No newline at end of file
diff --git a/_locales/nl/machine-learning-strings.json b/_locales/nl/machine-learning-strings.json
new file mode 100644
index 0000000..969beb1
--- /dev/null
+++ b/_locales/nl/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "onbekend",
+  "ml.getCertainty|block": "zekerheid (\\%) ML $event",
+  "ml.isDetected|block": "is ML $event gedetecteerd",
+  "ml.onStart|block": "op ML $event start",
+  "ml.onStopDetailed|block": "op ML $event stop $duration (ms)",
+  "ml.onStop|block": "op ML $event stop",
+  "ml|block": "Machine Learning",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/pl/machine-learning-jsdoc-strings.json b/_locales/pl/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..7f46450
--- /dev/null
+++ b/_locales/pl/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "Uzyskaj pewność zdarzenia ML w procentach (od 0 do 100).",
+  "ml.getCertainty|param|event": "jedna z czynności, na które został wytrenowany model nauczania maszynowego",
+  "ml.isDetected": "Testuje, czy zdarzenie ML jest obecnie wykryte.",
+  "ml.isDetected|param|event": "jedna z czynności, na które został wytrenowany model nauczania maszynowego",
+  "ml.onStart": "Zrób coś, gdy wykryto zdarzenie ML",
+  "ml.onStart|param|body": "kod do wykonania",
+  "ml.onStart|param|event": "jedna z czynności, na które został wytrenowany model nauczania maszynowego",
+  "ml.onStop": "Zrób coś, gdy zdarzenie ML nie jest już wykrywane.",
+  "ml.onStopDetailed": "Zrób coś, gdy zdarzenie ML nie jest już wykrywane.",
+  "ml.onStopDetailed|param|body": "kod do wykonania",
+  "ml.onStopDetailed|param|event": "jedna z czynności, na które został wytrenowany model nauczania maszynowego",
+  "ml.onStop|param|body": "kod do wykonania",
+  "ml.onStop|param|event": "jedna z czynności, na które został wytrenowany model nauczania maszynowego"
+}
\ No newline at end of file
diff --git a/_locales/pl/machine-learning-strings.json b/_locales/pl/machine-learning-strings.json
new file mode 100644
index 0000000..15aab74
--- /dev/null
+++ b/_locales/pl/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "nieznany",
+  "ml.getCertainty|block": "pewność (\\%) ML $event",
+  "ml.isDetected|block": "czy wykryto ML $event",
+  "ml.onStart|block": "przy starcie ML $event",
+  "ml.onStopDetailed|block": "przy ML $event stop $duration (ms)",
+  "ml.onStop|block": "przy zatrzymaniu ML $event",
+  "ml|block": "Uczenie maszynowe",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/pt-BR/machine-learning-jsdoc-strings.json b/_locales/pt-BR/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..17c2b5f
--- /dev/null
+++ b/_locales/pt-BR/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "Obtenha a probabilidade de um evento de ML em porcentagem (0 a 100).",
+  "ml.getCertainty|param|event": "uma das ações em que o modelo de aprendizado de máquina foi treinado",
+  "ml.isDetected": "Testa se um evento de ML está sendo detectado no momento.",
+  "ml.isDetected|param|event": "uma das ações em que o modelo de aprendizado de máquina foi treinado",
+  "ml.onStart": "Faz algo quando um evento de ML é detectado.",
+  "ml.onStart|param|body": "código a ser executado",
+  "ml.onStart|param|event": "uma das ações em que o modelo de aprendizado de máquina foi treinado",
+  "ml.onStop": "Faz algo quando um evento de ML não for mais detectado.",
+  "ml.onStopDetailed": "Faz algo quando um evento de ML não for mais detectado.",
+  "ml.onStopDetailed|param|body": "código a ser executado",
+  "ml.onStopDetailed|param|event": "uma das ações em que o modelo de aprendizado de máquina foi treinado",
+  "ml.onStop|param|body": "código a ser executado",
+  "ml.onStop|param|event": "uma das ações em que o modelo de aprendizado de máquina foi treinado"
+}
\ No newline at end of file
diff --git a/_locales/pt-BR/machine-learning-strings.json b/_locales/pt-BR/machine-learning-strings.json
new file mode 100644
index 0000000..6b5878a
--- /dev/null
+++ b/_locales/pt-BR/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "desconhecido",
+  "ml.getCertainty|block": "certeza (\\%) ML $event",
+  "ml.isDetected|block": "o ML $event foi detectado",
+  "ml.onStart|block": "no início do ML $event",
+  "ml.onStopDetailed|block": "no término ML $event $duration (ms)",
+  "ml.onStop|block": "o ML $event parou",
+  "ml|block": "Aprendizado de Máquina (ML)",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/_locales/zh-TW/machine-learning-jsdoc-strings.json b/_locales/zh-TW/machine-learning-jsdoc-strings.json
new file mode 100644
index 0000000..d913c7b
--- /dev/null
+++ b/_locales/zh-TW/machine-learning-jsdoc-strings.json
@@ -0,0 +1,15 @@
+{
+  "ml.getCertainty": "以百分比（0 至 100）獲取機器學習事件的確定性。",
+  "ml.getCertainty|param|event": "機器學習模型所受訓練的動作其中之一",
+  "ml.isDetected": "測試目前是否偵測到機器學習事件發生。",
+  "ml.isDetected|param|event": "機器學習模型所受訓練的動作其中之一",
+  "ml.onStart": "當偵測到機器學習事件時執行某些操作。\n\n",
+  "ml.onStart|param|body": "程式碼執行",
+  "ml.onStart|param|event": "機器學習模型所受訓練的動作其中之一",
+  "ml.onStop": "當不再偵測到機器學習事件時執行某些操作。",
+  "ml.onStopDetailed": "當不再偵測到機器學習事件時執行某些操作。",
+  "ml.onStopDetailed|param|body": "程式碼執行",
+  "ml.onStopDetailed|param|event": "機器學習模型所受訓練的動作其中之一",
+  "ml.onStop|param|body": "程式碼執行",
+  "ml.onStop|param|event": "機器學習模型所受訓練的動作其中之一"
+}
\ No newline at end of file
diff --git a/_locales/zh-TW/machine-learning-strings.json b/_locales/zh-TW/machine-learning-strings.json
new file mode 100644
index 0000000..540b8d4
--- /dev/null
+++ b/_locales/zh-TW/machine-learning-strings.json
@@ -0,0 +1,12 @@
+{
+  "ml.event.Unknown|block": "未知",
+  "ml.getCertainty|block": "確定性 (\\%) ML $event",
+  "ml.isDetected|block": "是否偵測到 ML $event",
+  "ml.onStart|block": "ML $event 開始時",
+  "ml.onStopDetailed|block": "ML $event 停止時 $duration（毫秒）",
+  "ml.onStop|block": "ML $event 停止時",
+  "ml|block": "機器學習",
+  "{id:category}Ml": "Ml",
+  "{id:category}MlEvent": "MlEvent",
+  "{id:group}micro:bit (V2)": "micro:bit (V2)"
+}
\ No newline at end of file
diff --git a/bin/update-translations.sh b/bin/update-translations.sh
new file mode 100755
index 0000000..6428462
--- /dev/null
+++ b/bin/update-translations.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+#
+# Partial automation of updating sim and extension translations.
+#
+# Updates sim and extension translations. 
+# 
+# New languages require code change below and in:
+# 1. Sim to add language in simx/src/messages/TranslationProvider.tsx.
+# 2. Extension config to include the file path in pxt.json.
+#
+
+set -euxo pipefail
+
+if [ $# -eq 0 ]; then
+  echo Missing argument to extracted Crowdin ZIP >&1
+  exit 1
+fi
+
+languages="es-ES ja ko nl pl pt-BR zh-TW"
+
+for language in $languages; do
+    lower="${language,,}"
+    prefix="${1}/${language}"
+    cp "${prefix}/ui.en.json" "simx/lang/ui.${lower}.json"
+
+    mkdir -p "_locales/${language}"
+    cp "${prefix}/machine-learning-jsdoc-strings.json" "_locales/${language}"
+    cp "${prefix}/machine-learning-strings.json" "_locales/${language}"
+
+    mkdir -p "docs/_locales/${language}"
+    cp -r "${prefix}/docs/." "docs/_locales/${language}"
+done
+
+cd simx
+npm run i18n:compile
+cd -
\ No newline at end of file
diff --git a/docs/_locales/es-ES/ml_get_event_certainty.md b/docs/_locales/es-ES/ml_get_event_certainty.md
new file mode 100644
index 0000000..e53c76f
--- /dev/null
+++ b/docs/_locales/es-ES/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+Obtiene el último valor de certeza de una acción ML.
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+El modelo ML se ejecuta varias veces por segundo y calcula un valor de certeza para cada acción. La acción estimada es la acción con mayor certeza. Una acción no puede ser la acción estimada cuando su certeza está por debajo del punto de reconocimiento. Es posible que algunos programas necesiten utilizar directamente los valores de certeza, por ejemplo para visualizarlos o registrarlos. La mayoría de los programas pueden utilizar la acción estimada en lugar de los valores de certeza.
+
+## Parámetros
+
+- **evento**: una de las acciones en las que se ha entrenado el modelo de aprendizaje automático.
+
+## Devuelve
+
+- un porcentaje como [número](/types/number) de 0 a 100, que representa la certeza del modelo ML de que ésta es la acción que se está realizando. La certeza para "unknown" es siempre 0.
+
+## Ejemplo
+
+Este ejemplo muestra la certeza del modelo ML, en porcentaje, de que la acción actual es "aplaudiendo" cada segundo.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/es-ES/ml_is_event_detected.md b/docs/_locales/es-ES/ml_is_event_detected.md
new file mode 100644
index 0000000..64a1971
--- /dev/null
+++ b/docs/_locales/es-ES/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# is ML detected
+
+Comprueba si una acción ML es la acción estimada.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+El modelo ML actualiza su acción estimada varias veces por segundo. Esta función devuelve "cierto" si la acción elegida está actualmente estimada. Utiliza el valor booleano para tomar decisiones lógicas en tu programa.
+
+Algunos programas serán más fáciles de escribir utilizando los manejadores de eventos «on ML start» y «on ML stop» en su lugar.
+
+## Parámetros
+
+- **evento**: una de las acciones en las que se ha entrenado el modelo de aprendizaje automático. El valor especial `unknown` representa el caso en que ninguna acción tiene una certeza superior al punto de reconocimiento.
+
+## Devuelve
+
+- un valor [booleano](/types/boolean) que es `cierto` si la acción ML es la acción estimada, `falso` si la acción ML no es la acción estimada.
+
+## Ejemplo
+
+Este ejemplo mostrará un icono de tic en la pantalla LED si la acción estimada es `aplaudiendo` en el momento en que se comprueba la sentencia condicional.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/es-ES/ml_on_event_start.md b/docs/_locales/es-ES/ml_on_event_start.md
new file mode 100644
index 0000000..00f07ee
--- /dev/null
+++ b/docs/_locales/es-ES/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# on ML start
+
+Inicia un [manejador de eventos](/reference/event-handler) (parte del programa que se ejecutará cuando algo suceda). Este manejador funciona cuando la acción estimada del modelo ML cambia a la acción que tú seleccionas.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+El modelo ML actualiza su acción estimada varias veces por segundo, pero este controlador de eventos solo se ejecuta cuando cambia la acción estimada.
+
+## Parámetros
+
+- **evento**: una de las acciones en las que se ha entrenado el modelo de aprendizaje automático. El valor especial `unknown` representa el caso en que ninguna acción tiene una certeza superior al punto de reconocimiento.
+
+## Ejemplo
+
+Este ejemplo reproduce una melodía musical de fondo cuando la acción «aplaudir» tiene una certeza superior al punto de reconocimiento.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/es-ES/ml_on_event_stop.md b/docs/_locales/es-ES/ml_on_event_stop.md
new file mode 100644
index 0000000..66108a4
--- /dev/null
+++ b/docs/_locales/es-ES/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# al detenerse el ML
+
+Inicia un [manejador de eventos](/reference/event-handler) (parte del programa que se ejecutará cuando algo suceda). Este controlador funciona cuando la acción estimada del modelo ML cambia respecto a la acción que seleccionaste.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+Cuando cambie una acción, se ejecutará el controlador de eventos de parada de la acción anterior, seguido del controlador de eventos de inicio de la acción siguiente.
+
+Por ejemplo, si el controlador de eventos de inicio de una acción inicia la reproducción de música en segundo plano, puedes utilizar un controlador de eventos de parada para detenerla.
+
+## Parámetros
+
+- **evento**: una de las acciones en las que se ha entrenado el modelo de aprendizaje automático. El valor especial `unknown` representa el caso en que ninguna acción tiene una certeza superior al punto de reconocimiento.
+
+## Ejemplo
+
+Este ejemplo detiene la reproducción de una melodía musical cuando la acción estimada cambia de «aplaudir» a cualquier otra acción.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/es-ES/ml_on_event_stop_detailed.md b/docs/_locales/es-ES/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..63bf110
--- /dev/null
+++ b/docs/_locales/es-ES/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# al detenerse el ML
+
+Inicia un [manejador de eventos](/reference/event-handler) (parte del programa que se ejecutará cuando algo suceda). Este controlador funciona cuando la acción estimada del modelo ML cambia respecto a la acción que seleccionaste.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+Cuando cambie una acción, se ejecutará el controlador de eventos de parada de la acción anterior, seguido del controlador de eventos de inicio de la acción siguiente.
+
+Por ejemplo, si el controlador de eventos de inicio de una acción inicia la reproducción de música en segundo plano, puedes utilizar un controlador de eventos de parada para detenerla.
+
+Al controlador del evento se le pasa un parámetro de «duración». La duración es el [número](/types/number) de milisegundos desde que esta acción se convirtió en la acción estimada. Puedes utilizar el parámetro de duración en tu código; por ejemplo, mostrándolo o utilizando una variable para mantener un total actualizado.
+
+## Parámetros
+
+- **evento**: una de las acciones en las que se ha entrenado el modelo de aprendizaje automático. El valor especial `unknown` representa el caso en que ninguna acción tiene una certeza superior al punto de reconocimiento.
+
+## Ejemplo
+
+Este ejemplo muestra en la pantalla LED, en segundos, cuánto tiempo ha durado la acción estimada de «aplaudir», cuando la acción estimada cambia de «aplaudir» a cualquier otra acción.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ja/ml_get_event_certainty.md b/docs/_locales/ja/ml_get_event_certainty.md
new file mode 100644
index 0000000..9e48f56
--- /dev/null
+++ b/docs/_locales/ja/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+MLの動きの確実性の値を取得します。
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+MLモデルは1秒間に数回実行され、各アクションの確実性の値を算出します。 推定した動きは、最も高い確実性を持つ動きです。 An action cannot be the estimated action when its certainty is below the recognition point. Some programs may need to use the certainty values directly, for example to display or log them. Most programs can use the estimated action instead of certainty values.
+
+## パラメータ
+
+- **event**: one of the actions the machine learning model was trained on.
+
+## Returns
+
+- a percentage as a [number](/types/number) from 0 to 100, representing the ML model’s certainty that this is the action being performed. The certainty for `unknown` is always 0.
+
+## 例
+
+This example displays the ML model's certainty, in percent, that the current action is `clapping` every second.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ja/ml_is_event_detected.md b/docs/_locales/ja/ml_is_event_detected.md
new file mode 100644
index 0000000..63d85a0
--- /dev/null
+++ b/docs/_locales/ja/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# is ML detected
+
+Checks if an ML action is the estimated action.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+The ML model updates its estimated action several times a second. This function returns `true` if the chosen action is currently estimated. Use the boolean value to make logical decisions in your program.
+
+Some programs will be easier to write using the “on ML start” and “on ML stop” event handlers instead.
+
+## パラメータ
+
+- **event**: one of the actions the machine learning model was trained on. The special value `unknown` represents the case where no action has a certainty above the recognition point.
+
+## Returns
+
+- a [boolean](/types/boolean) value that is `true` if the ML action is the estimated action, `false` if the ML action is not the estimated action.
+
+## 例
+
+This example will show a tick icon on the LED display if the estimated action is `clapping` at the time the conditional statement is checked.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ja/ml_on_event_start.md b/docs/_locales/ja/ml_on_event_start.md
new file mode 100644
index 0000000..e86f146
--- /dev/null
+++ b/docs/_locales/ja/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# MLが開始したとき
+
+Start an [event handler](/reference/event-handler) (part of the program that will run when something happens). This handler works when the ML model’s estimated action changes to the action you select.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+The ML model updates its estimated action several times a second, but this event handler only runs when the estimated action changes.
+
+## パラメータ
+
+- **event**: one of the actions the machine learning model was trained on. The special value `unknown` represents the case where no action has a certainty above the recognition point.
+
+## 例
+
+This example plays a musical melody in the background when the action `clapping` has a certainty above the recognition point.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ja/ml_on_event_stop.md b/docs/_locales/ja/ml_on_event_stop.md
new file mode 100644
index 0000000..a0669fd
--- /dev/null
+++ b/docs/_locales/ja/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# on ML stop
+
+Start an [event handler](/reference/event-handler) (part of the program that will run when something happens). This handler works when the ML model’s estimated action changes from the action you select.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+When an action changes, the stop event handler for the previous action will run, followed by the start event handler for the next action.
+
+For example, if your start event handler for an action starts music playing in the background, you could use a stop event handler to stop it.
+
+## パラメータ
+
+- **event**: one of the actions the machine learning model was trained on. The special value `unknown` represents the case where no action has a certainty above the recognition point.
+
+## 例
+
+This example stops playing a musical melody when the estimated action changes from `clapping` to any other action.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ja/ml_on_event_stop_detailed.md b/docs/_locales/ja/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..35334e9
--- /dev/null
+++ b/docs/_locales/ja/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# on ML stop
+
+Start an [event handler](/reference/event-handler) (part of the program that will run when something happens). This handler works when the ML model’s estimated action changes from the action you select.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+When an action changes, the stop event handler for the previous action will run, followed by the start event handler for the next action.
+
+For example, if your start event handler for an action starts music playing in the background, you could use a stop event handler to stop it.
+
+The event handler is passed a `duration` parameter. The duration is the [number](/types/number) of milliseconds since this action became the estimated action. You can use the duration parameter in your code, for example displaying it or using a variable to keep a running total.
+
+## パラメータ
+
+- **event**: one of the actions the machine learning model was trained on. The special value `unknown` represents the case where no action has a certainty above the recognition point.
+
+## 例
+
+This example shows on the LED display, in seconds, how long the estimated action was `clapping`, when the estimated action changes from `clapping` to any other action.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ko/ml_get_event_certainty.md b/docs/_locales/ko/ml_get_event_certainty.md
new file mode 100644
index 0000000..2aa1b74
--- /dev/null
+++ b/docs/_locales/ko/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+ML 작업에 대한 최신 확실성 값 얻기.
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+ML 모델은 초당 여러 번 실행되며 각 행동에 대한 확실성을 계산합니다. 예측한 행동은 확실성이 가장 높은 행동입니다. 어떤 행동의 확실성이 인식 지점(Recognition point)보다 낮다면 해당 행동은 추정되는 행동이 아닙니다. 어떤 프로그램에서는 확실성 수치를 표시하거나 기록하는 등 이 수치를 직접 사용해야 할 수 있습니다. 대부분의 프로그램은 확실성 수치 대신 추정되는 행동을 사용합니다.
+
+## 매개 변수
+
+- **이벤트**: 기계 학습 모델이 학습한 행동 중 하나
+
+## 반환
+
+- 0에서 100까지의 [number](/types/number)로 표시되는 백분율로, 수행하고 있는 행동에 대한 ML 모델의 확실성을 나타냅니다. '알 수 없음'의 확실성은 항상 0입니다.
+
+## 예시
+
+이 예시는 현재 행동이 매초 '박수'를 치고 있다는 ML 모델의 확실성을 백분율로 표시합니다.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ko/ml_is_event_detected.md b/docs/_locales/ko/ml_is_event_detected.md
new file mode 100644
index 0000000..24cb9f3
--- /dev/null
+++ b/docs/_locales/ko/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# ML이 감지되었나요?
+
+ML이 행동을 예측했는지 확인합니다.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+ML 모델은 추정되는 행동을 1초에 여러 번 업데이트합니다. 이 함수는 선택된 동작이 현재 추정되는 경우 `true`를 반환합니다. 프로그램에서 논리적인 판단을 하려면 부울 값을 사용하세요.
+
+대신 'ML 시작 시(on ML start)'와 'ML 중지 시(on ML stop)' 이벤트 핸들러를 사용하면 일부 프로그램에서 더 쉽게 작성할 수 있습니다.
+
+## 매개 변수
+
+- **이벤트**: 기계 학습 모델이 학습한 행동 중 하나 `알 수 없음`이라는 특수값은 인식 지점 이상의 확실성이 있는 행동이 없는 경우를 나타냅니다.
+
+## 반환
+
+- [boolean](/types/boolean) 값은 ML 행동이 추정되는 행동인 경우 '참'이고, ML 행동이 추정되는 행동이 아닌 경우 '거짓'입니다.
+
+## 예시
+
+이 예시에서는 조건문이 확인될 때 추정되는 행동이 `박수 치기`인 경우 LED 디스플레이에 체크 표시 아이콘이 표시됩니다.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ko/ml_on_event_start.md b/docs/_locales/ko/ml_on_event_start.md
new file mode 100644
index 0000000..9fa6357
--- /dev/null
+++ b/docs/_locales/ko/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# ML 시작 시
+
+[event handler](/reference/event-handler)를 시작합니다(어떤 일이 일어날 때 실행되는 프로그램의 일부). 이 핸들러는 ML 모델의 추정되는 행동이 사용자가 선택한 행동으로 변경될 때 작동합니다.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+ML 모델은 추정되는 행동을 초당 여러 번 업데이트하지만, 이 이벤트 핸들러는 추정된 행동이 변경될 때만 실행됩니다.
+
+## 매개 변수
+
+- **이벤트**: 기계 학습 모델이 학습한 행동 중 하나 `알 수 없음`이라는 특수값은 인식 지점 이상의 확실성이 있는 행동이 없는 경우를 나타냅니다.
+
+## 예시
+
+이 예시에서는 인식 지점보다 `박수 치기` 행동의 확실성이 높을 때 백그라운드에서 음악 멜로디가 재생됩니다.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ko/ml_on_event_stop.md b/docs/_locales/ko/ml_on_event_stop.md
new file mode 100644
index 0000000..17229ec
--- /dev/null
+++ b/docs/_locales/ko/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# ML 중지 시
+
+[event handler](/reference/event-handler)를 시작합니다(어떤 일이 일어날 때 실행되는 프로그램의 일부). 이 핸들러는 ML 모델의 추정 행동이 사용자가 선택한 행동에서 변경될 때 작동합니다.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+행동이 변경되면 이전 행동에 대한 정지 이벤트 핸들러가 실행된 후, 다음 행동에 대한 시작 이벤트 핸들러가 실행됩니다.
+
+예를 들어, 행동에 대한 시작 이벤트 핸들러가 백그라운드에서 음악을 재생하기 시작하면 중지 이벤트 핸들러로 이를 멈출 수 있습니다.
+
+## 매개 변수
+
+- **이벤트**: 기계 학습 모델이 학습한 행동 중 하나 `알 수 없음`이라는 특수값은 인식 지점 이상의 확실성이 있는 행동이 없는 경우를 나타냅니다.
+
+## 예시
+
+이 예시에서는 추정되는 행동이 '박수 치기'에서 다른 행동으로 변경되면 음악 멜로디 재생이 멈춥니다.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/ko/ml_on_event_stop_detailed.md b/docs/_locales/ko/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..fe7103f
--- /dev/null
+++ b/docs/_locales/ko/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# ML 중지 시
+
+[event handler](/reference/event-handler)를 시작합니다(어떤 일이 일어날 때 실행되는 프로그램의 일부). 이 핸들러는 ML 모델의 추정 행동이 사용자가 선택한 행동에서 변경될 때 작동합니다.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+행동이 변경되면 이전 행동에 대한 정지 이벤트 핸들러가 실행된 후, 다음 행동에 대한 시작 이벤트 핸들러가 실행됩니다.
+
+예를 들어, 행동에 대한 시작 이벤트 핸들러가 백그라운드에서 음악을 재생하기 시작하면 중지 이벤트 핸들러로 이를 멈출 수 있습니다.
+
+이벤트 핸들러에 '지속 시간' 매개변수가 전송됩니다. 이 행동이 추정되는 행동이 된 이후 지속 시간은 [number](/types/number)밀리초입니다. 코드에서 지속 시간 매개변수를 사용하여 이를 표시하거나 변수를 사용하여 누적 시간을 계속 계산할 수 있습니다.
+
+## 매개 변수
+
+- **이벤트**: 기계 학습 모델이 학습한 행동 중 하나 `알 수 없음`이라는 특수값은 인식 지점 이상의 확실성이 있는 행동이 없는 경우를 나타냅니다.
+
+## 예시
+
+이 예시에서는 예상되는 행동이 '박수 치기'에서 다른 행동으로 변경될 때, 예상 행동 '박수'였던 시간을 초 단위로 LED 디스플레이에 표시합니다.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/nl/ml_get_event_certainty.md b/docs/_locales/nl/ml_get_event_certainty.md
new file mode 100644
index 0000000..8e390ed
--- /dev/null
+++ b/docs/_locales/nl/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+Haalt de laatste zekerheidswaarde op voor een ML actie.
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+Het ML-model loopt meerdere keren per seconde en berekent een zekerheidswaarde voor elke actie. De geschatte actie is de actie met de hoogste zekerheid. Een actie kan niet de geschatte actie zijn als de zekerheid onder het herkenningspunt ligt. Sommige programma's moeten mogelijk de zekerheidswaarden direct gebruiken, bijvoorbeeld om ze weer te geven of te loggen. De meeste programma's kunnen de geschatte actie gebruiken in plaats van de zekerheidswaarden.
+
+## Parameters
+
+- **gebeurtenis**: een van de acties waarop het machine-learning is getraind.
+
+## Retourneert
+
+- een percentage als een [getal](/types/number) van 0 tot 100, dat de zekerheid van het ML-model weergeeft dat dit de actie is die wordt uitgevoerd. De zekerheid voor `unknown` is altijd 0.
+
+## Voorbeeld
+
+Dit voorbeeld toont de zekerheid van het ML-model in procenten, dat de huidige actie elke seconde 'klappen' is.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/nl/ml_is_event_detected.md b/docs/_locales/nl/ml_is_event_detected.md
new file mode 100644
index 0000000..241b92e
--- /dev/null
+++ b/docs/_locales/nl/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# is ML gedetecteerd
+
+Controleert of een ML-actie de geschatte actie is.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+Het ML-model actualiseert zijn geschatte actie meerdere keren per seconde. Deze functie retourneert `true` als de gekozen actie momenteel is ingeschat. Gebruik de booleaanse waarde om logische beslissingen te nemen in je programma.
+
+Sommige programma's zullen gemakkelijker te schrijven zijn met behulp van de "on ML start" en "on ML stop" event handlers .
+
+## Parameters
+
+- **gebeurtenis**: een van de acties waarop het machine-learning is getraind. De speciale waarde `unknown` vertegenwoordigt het geval waar geen actie een zekerheid heeft boven het herkenningspunt.
+
+## Retourneert
+
+- een [boolean](/types/boolean) waarde die 'true' is als de ML actie de geschatte actie is, `false` als de ML actie niet de geschatte actie is.
+
+## Voorbeeld
+
+Dit voorbeeld toont een vinkje pictogram op het LED display als de geschatte actie 'klappen' is op het moment dat de voorwaardelijke opdracht is gecontroleerd.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/nl/ml_on_event_start.md b/docs/_locales/nl/ml_on_event_start.md
new file mode 100644
index 0000000..a1f76fd
--- /dev/null
+++ b/docs/_locales/nl/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# op ML start
+
+Start een [event handler](/reference/event-handler) (deel van het programma dat wordt uitgevoerd wanneer er iets gebeurt). Deze handler werkt wanneer de ingeschatte actie van het ML-model verandert in de actie die je selecteert.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+Het ML-model update zijn geschatte actie meerdere keren per seconde, maar deze event handler wordt alleen uitgevoerd wanneer de geschatte actie verandert.
+
+## Parameters
+
+- **gebeurtenis**: een van de acties waarop het machine-learning is getraind. De speciale waarde `unknown` vertegenwoordigt het geval waar geen actie een zekerheid heeft boven het herkenningspunt.
+
+## Voorbeeld
+
+Dit voorbeeld speelt een muzikale melodie op de achtergrond wanneer de actie `klappen` een zekerheid boven het herkenningspunt heeft.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/nl/ml_on_event_stop.md b/docs/_locales/nl/ml_on_event_stop.md
new file mode 100644
index 0000000..7ada1a6
--- /dev/null
+++ b/docs/_locales/nl/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# op ML  stop
+
+Start een [event handler](/reference/event-handler) (deel van het programma dat wordt uitgevoerd wanneer er iets gebeurt). Deze handler werkt wanneer de ingeschatte actie van het ML-model verandert in de actie die je selecteert.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+Als een actie verandert, wordt de stop event handler voor de vorige actie uitgevoerd, gevolgd door de start event handler voor de volgende actie.
+
+Bijvoorbeeld, als je start event-handler zorgt voor een actie die muziek afspeelt op de achtergrond kun je een stop-event-handler gebruiken om deze te stoppen.
+
+## Parameters
+
+- **gebeurtenis**: een van de acties waarop het machine-learning is getraind. De speciale waarde `unknown` vertegenwoordigt het geval waar geen actie een zekerheid heeft boven het herkenningspunt.
+
+## Voorbeeld
+
+Dit voorbeeld stopt met het spelen van een muzikale melodie wanneer de geschatte actie verandert van `klappen` naar een andere actie.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/nl/ml_on_event_stop_detailed.md b/docs/_locales/nl/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..5fc522a
--- /dev/null
+++ b/docs/_locales/nl/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# op ML  stop
+
+Start een [event handler](/reference/event-handler) (deel van het programma dat wordt uitgevoerd wanneer er iets gebeurt). Deze handler werkt wanneer de ingeschatte actie van het ML-model verandert in de actie die je selecteert.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+Als een actie verandert, wordt de stop event handler voor de vorige actie uitgevoerd, gevolgd door de start event handler voor de volgende actie.
+
+Bijvoorbeeld, als je start event-handler zorgt voor een actie die muziek afspeelt op de achtergrond kun je een stop-event-handler gebruiken om deze te stoppen.
+
+Aan de event handler wordt een 'tijdsduur' (duration) parameter doorgegeven. De tijdsduur is het [aantal](/types/nummer) milliseconden sinds deze actie de geschatte actie werd. Je kunt de tijdsduur parameter gebruiken in je code, bijvoorbeeld om deze weer te geven of om een variabele te gebruiken om het totaal te bij te houden.
+
+## Parameters
+
+- **gebeurtenis**: een van de acties waarop het machine-learning is getraind. De speciale waarde `unknown` vertegenwoordigt het geval waar geen actie een zekerheid heeft boven het herkenningspunt.
+
+## Voorbeeld
+
+Dit voorbeeld laat zien op het LED-display, in seconden, hoe lang de geschatte actie `klappen` was, wanneer de ingeschat actie verandert van `klappen` naar een andere actie.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pl/ml_get_event_certainty.md b/docs/_locales/pl/ml_get_event_certainty.md
new file mode 100644
index 0000000..66795ea
--- /dev/null
+++ b/docs/_locales/pl/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+Pobiera najnowszą wartość pewności dla działania ML
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+Model ML działa kilka razy na sekundę i oblicza wartość pewności dla każdego działania. Oszacowanym działaniem jest działanie z najwyższą pewnością. Działanie nie może być działaniem szacowanym, jeżeli jego pewność jest niższa od punktu rozpoznania. Niektóre programy mogą wymagać użycia wartości pewności bezpośrednio, na przykład, aby je wyświetlić lub zarejestrować. Większość programów może wykorzystywać szacowane działanie zamiast wartości pewności.
+
+## Parametry
+
+- **zdarzenie**: jedna z akcji, na której trenowano model uczenia maszynowego.
+
+## Wyniki
+
+- procent jako [liczba](/types/number) od 0 do 100, reprezentujący pewność modelu ML, że jest to wykonywana czynność. Pewność dla `unknown` jest zawsze 0.
+
+## Przykład
+
+Ten przykład wyświetla pewność modelu ML w procentach, że bieżącą akcją jest `klaśnięcie` co sekundę.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pl/ml_is_event_detected.md b/docs/_locales/pl/ml_is_event_detected.md
new file mode 100644
index 0000000..ef4bf74
--- /dev/null
+++ b/docs/_locales/pl/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# czy wykryto ML
+
+Sprawdza, czy działanie ML jest działaniem szacunkowym.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+Model ML aktualizuje swoją szacunkową akcję kilka razy na sekundę. Ta funkcja zwraca `true`, jeśli wybrana akcja jest obecnie szacowana. Użyj wartości logicznej do podejmowania decyzji logicznych w swoim programie.
+
+Niektóre programy będą łatwiejsze do napisania przy użyciu obsługi zdarzeń „on ML start” i „on ML stop”.
+
+## Parametry
+
+- **zdarzenie**: jedna z akcji, na której trenowano model uczenia maszynowego. Wartość specjalna `unknown` reprezentuje przypadek, w którym żadna akcja nie ma pewności powyżej punktu rozpoznania.
+
+## Wyniki
+
+- wartość [logiczna](/types/boolean), która jest `true`, jeśli akcja ML jest szacowaną akcją, `false`, jeśli akcja ML nie jest szacowanym działaniem.
+
+## Przykład
+
+Ten przykład wyświetli ikonę potwierdzenia na wyświetlaczu LED, jeśli szacowana akcja to `klaskanie` w momencie sprawdzania instrukcji warunkowej.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pl/ml_on_event_start.md b/docs/_locales/pl/ml_on_event_start.md
new file mode 100644
index 0000000..d93b511
--- /dev/null
+++ b/docs/_locales/pl/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# na rozpoczęcie ML
+
+Rozpocznij [obsługę zdarzeń](/reference/event-handler) (część programu, która uruchomi się, gdy coś się stanie). Ten moduł obsługi działa, gdy szacowane działanie modelu ML zmieni się na działanie wybrane przez Ciebie.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+Model ML aktualizuje swoje szacowane działanie kilka razy na sekundę, ale ten system obsługi zdarzeń działa tylko wtedy, gdy szacowane działanie się zmienia.
+
+## Parametry
+
+- **zdarzenie**: jedna z akcji, na której trenowano model uczenia maszynowego. Wartość specjalna `unknown` reprezentuje przypadek, w którym żadna akcja nie ma pewności powyżej punktu rozpoznania.
+
+## Przykład
+
+Ten przykład odtwarza melodię muzyczną w tle, gdy akcja `klaskanie` ma pewność powyżej punktu rozpoznania.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pl/ml_on_event_stop.md b/docs/_locales/pl/ml_on_event_stop.md
new file mode 100644
index 0000000..2cacbf5
--- /dev/null
+++ b/docs/_locales/pl/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# na zatrzymanie ML
+
+Rozpocznij [obsługę zdarzeń](/reference/event-handler) (część programu, która uruchomi się, gdy coś się stanie). Ten moduł obsługi działa, gdy szacowane działanie modelu ML zmieni się na działanie wybrane przez Ciebie.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+Gdy akcja się zmieni, program obsługi zdarzenia zatrzymania dla poprzedniej akcji zostanie uruchomiony, a następnie program obsługi zdarzenia rozpoczęcia dla następnej akcji.
+
+Na przykład, jeśli obsługa zdarzenia start dla danej akcji powoduje odtwarzanie muzyki w tle, możesz użyć obsługi zdarzenia stop, aby ją zatrzymać.
+
+## Parametry
+
+- **zdarzenie**: jedna z akcji, na której trenowano model uczenia maszynowego. Wartość specjalna `unknown` reprezentuje przypadek, w którym żadna akcja nie ma pewności powyżej punktu rozpoznania.
+
+## Przykład
+
+Ten przykład zatrzymuje odtwarzanie melodii muzycznej, gdy szacowane działanie zmienia się z `klaskania` na jakąkolwiek inną akcję.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pl/ml_on_event_stop_detailed.md b/docs/_locales/pl/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..c435723
--- /dev/null
+++ b/docs/_locales/pl/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# na zatrzymanie ML
+
+Rozpocznij [obsługę zdarzeń](/reference/event-handler) (część programu, która uruchomi się, gdy coś się stanie). Ten moduł obsługi działa, gdy szacowane działanie modelu ML zmieni się na działanie wybrane przez Ciebie.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+Gdy akcja się zmieni, program obsługi zdarzenia zatrzymania dla poprzedniej akcji zostanie uruchomiony, a następnie program obsługi zdarzenia rozpoczęcia dla następnej akcji.
+
+Na przykład, jeśli obsługa zdarzenia start dla danej akcji powoduje odtwarzanie muzyki w tle, możesz użyć obsługi zdarzenia stop, aby ją zatrzymać.
+
+Do obsługi zdarzeń przekazywany jest parametr `duration`. Czas trwania to [liczba](/types/number) milisekund, ponieważ ta akcja stała się działaniem szacunkowym. Możesz użyć parametru czasu trwania w swoim kodzie, na przykład wyświetlając go lub używając zmiennej, aby zachować sumę bieżącą.
+
+## Parametry
+
+- **zdarzenie**: jedna z akcji, na której trenowano model uczenia maszynowego. Wartość specjalna `unknown` reprezentuje przypadek, w którym żadna akcja nie ma pewności powyżej punktu rozpoznania.
+
+## Przykład
+
+Ten przykład pokazuje na wyświetlaczu LED, w sekundach, jak długo szacowaną akcją było `klaskanie`, kiedy szacowane działanie zmienia się z `klaskania` na inne działanie.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pt-BR/ml_get_event_certainty.md b/docs/_locales/pt-BR/ml_get_event_certainty.md
new file mode 100644
index 0000000..0dfa317
--- /dev/null
+++ b/docs/_locales/pt-BR/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+Obtém o valor de certeza mais recente para uma ação de ML.
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+O modelo de ML é executado várias vezes por segundo e calcula um valor de certeza para cada ação. A ação estimada é aquela com a maior certeza. Uma ação não pode ser a ação estimada quando sua certeza estiver abaixo do ponto de reconhecimento. Alguns programas podem precisar usar os valores de certeza diretamente, por exemplo, para exibi-los ou registrá-los. A maioria dos programas pode usar ações estimadas em vez dos valores de certeza.
+
+## Parâmetros
+
+- **evento**: uma das ações nas quais o modelo de aprendizado de máquina foi treinado.
+
+## Retornos
+
+- uma porcentagem como um [número](/types/number) de 0 a 100, representando a certeza do modelo de ML de que esta é a ação que está sendo realizada. A certeza para `unknown` é sempre 0.
+
+## Exemplo
+
+Este exemplo mostra a certeza do modelo de ML, em porcentagem, de que a ação atual é `clapping` (bater palmas) a cada segundo.
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pt-BR/ml_is_event_detected.md b/docs/_locales/pt-BR/ml_is_event_detected.md
new file mode 100644
index 0000000..863f610
--- /dev/null
+++ b/docs/_locales/pt-BR/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# is ML detected
+
+Verifica se uma ação de ML é a ação estimada.
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+O modelo de ML atualiza sua estimativa de ação várias vezes por segundo. Esta função retorna `true` se a ação escolhida for a estimada no momento. Use o valor booleano para tomar decisões lógicas no seu programa.
+
+Alguns programas serão mais fáceis de escrever usando, em vez disso, os manipuladores de evento "on ML start" e "on ML stop".
+
+## Parâmetros
+
+- **evento**: uma das ações nas quais o modelo de aprendizado de máquina foi treinado. O valor especial `unknown` (desconhecido) representa o caso em que nenhuma ação tem uma certeza acima do ponto de reconhecimento.
+
+## Retornos
+
+- um valor [boolean](/types/boolean) que é `true` se a ação de ML for a ação estimada ou `false` se a ação de ML não for a ação estimada.
+
+## Exemplo
+
+Este exemplo exibirá um ícone de conferido no visor de LED se a ação estimada for `clapping` (bater palmas) no momento exato em que os comandos condicionais forem verificados.
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pt-BR/ml_on_event_start.md b/docs/_locales/pt-BR/ml_on_event_start.md
new file mode 100644
index 0000000..caff6da
--- /dev/null
+++ b/docs/_locales/pt-BR/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# on ML start
+
+Inicie um [manipulador de evento](/reference/event-handler) (parte do programa que será executada quando algo acontecer). Este manipulador de evento é disparado quando a ação estimada pelo modelo de ML muda para a ação que você selecionou.
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+O modelo de ML atualiza sua ação estimada várias vezes por segundo, mas esse manipulador de evento só é acionado quando a ação estimada muda.
+
+## Parâmetros
+
+- **evento**: uma das ações nas quais o modelo de aprendizado de máquina foi treinado. O valor especial `unknown` representa o caso em que nenhuma ação tem uma certeza acima do ponto de reconhecimento.
+
+## Exemplo
+
+Este exemplo reproduz uma melodia musical em segundo plano quando a ação `clapping` (bater palmas) tem uma certeza acima do ponto de reconhecimento.
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pt-BR/ml_on_event_stop.md b/docs/_locales/pt-BR/ml_on_event_stop.md
new file mode 100644
index 0000000..68ff60f
--- /dev/null
+++ b/docs/_locales/pt-BR/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# on ML stop
+
+Inicie um [manipulador de eventos](/reference/event-handler) (parte do programa que será executada quando algo acontecer). Este manipulador é acionado quando a ação estimada pelo modelo de ML muda da ação que você selecionou.
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+Quando uma ação muda, o manipulador de eventos de parada da ação anterior será executado, seguido pelo manipulador de eventos de início da próxima ação.
+
+Por exemplo, se o manipulador de eventos de início para uma ação começar a reprodução de música em segundo plano, você pode usar um manipulador de eventos de parada para interrompê-la.
+
+## Parâmetros
+
+- **evento**: uma das ações nas quais o modelo de aprendizado de máquina foi treinado. O valor especial `unknown` representa o caso em que nenhuma ação tem uma certeza acima do ponto de reconhecimento.
+
+## Exemplo
+
+Este exemplo para de tocar uma melodia musical quando a ação estimada muda de `clapping` (bater palmas) para qualquer outra ação.
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/pt-BR/ml_on_event_stop_detailed.md b/docs/_locales/pt-BR/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..08a6bf3
--- /dev/null
+++ b/docs/_locales/pt-BR/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# on ML stop
+
+Inicie um [manipulador de eventos](/reference/event-handler) (parte do programa que será executada quando algo acontecer). Este manipulador funciona quando a ação estimada pelo modelo de ML muda da ação que você selecionou.
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+Quando uma ação muda, o manipulador de eventos de parada da ação anterior será executado, seguido pelo manipulador de eventos de início da próxima ação.
+
+Por exemplo, se o seu manipulador de eventos para início de uma ação começar a reprodução de música em segundo plano, você pode usar um manipulador de eventos de parada para interrompê-la.
+
+O manipulador de eventos recebe um parâmetro chamado `duration`. A duração é o [número](/types/number) de milissegundos desde que esta ação passou a ser a ação estimada. Você pode usar o parâmetro de duração no seu código, por exemplo, exibindo-o ou usando uma variável para manter um total acumulado.
+
+## Parâmetros
+
+- **evento**: uma das ações nas quais o modelo de aprendizado de máquina foi treinado. O valor especial `unknown` representa o caso em que nenhuma ação tem uma certeza acima do ponto de reconhecimento.
+
+## "Exemplo"
+
+Este exemplo mostra no display de LED, em segundos, a duração da ação estimada como `bater palmas`, quando a ação estimada muda de `bater palmas` para qualquer outra ação.
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/zh-TW/ml_get_event_certainty.md b/docs/_locales/zh-TW/ml_get_event_certainty.md
new file mode 100644
index 0000000..bdf66f2
--- /dev/null
+++ b/docs/_locales/zh-TW/ml_get_event_certainty.md
@@ -0,0 +1,32 @@
+# certainty (%) ML
+
+取得機器學習動作的最新確定性數值。
+
+```sig
+ml.getCertainty(ml.event.Unknown)
+```
+
+機器學習模型每秒執行多次，並且計算各個動作的確定性數值。 預估動作是具有最高確定性的動作。 當某個動作的確定性低於辨識點時，它就不能成為預估動作。 有些程式可能需要直接地使用確定性數值，例如顯示或記錄這些數據。 大多數程式可以使用預估動作來取代確定性數值。
+
+## 參數
+
+- **事件**：機器學習模型所受訓練的動作其中之一。
+
+## 返回
+
+- 一個 0 到 100 之間的 [number](/types/number) 百分比，其表示機器學習模型對於這是正在進行的動作的確定程度。 「未知」的確定性始終為 0。
+
+## 範例
+
+這個範例顯示機器學習模型每秒鐘對於目前動作為「拍手」的確定性，依百分比表示。
+
+```blocks
+loops.everyInterval(1000, function () {
+    basic.showNumber(ml.getCertainty(ml.event.Clapping))
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/zh-TW/ml_is_event_detected.md b/docs/_locales/zh-TW/ml_is_event_detected.md
new file mode 100644
index 0000000..7486fdc
--- /dev/null
+++ b/docs/_locales/zh-TW/ml_is_event_detected.md
@@ -0,0 +1,36 @@
+# 是否偵測到機器學習
+
+檢查機器學習動作是否為預估動作。
+
+```sig
+ml.isDetected(ml.event.Unknown)
+```
+
+機器學習模型每秒多次更新其預估動作。 如果所選動作為目前所預估動作，則這個函式傳回「true」。 使用布林值在您的程式中做出邏輯判斷。
+
+有些程式則是另外利用「機器學習啟動時」和「機器學習停止時」事件處理程序來寫入會比較簡單。
+
+## 參數
+
+- **事件**：機器學習模型所受訓練的動作其中之一。 特殊值「未知」代表沒有任何動作具有高於辨識點的確定性的情況。
+
+## 返回值
+
+- 一個 [boolean](/types/boolean) 數值，如果機器學習動作是預估動作，則為「true」；如果機器學習動作不是預估動作，則為「false」。
+
+## 範例
+
+如果當檢查條件陳述式時所預估動作是「拍手」，則這個範例將會在 LED 顯示器上顯示勾號圖示。
+
+```blocks
+basic.forever(function () {
+    if (ml.isDetected(ml.event.Clapping)) {
+        basic.showIcon(IconNames.Yes)
+    }
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/zh-TW/ml_on_event_start.md b/docs/_locales/zh-TW/ml_on_event_start.md
new file mode 100644
index 0000000..a35c7e6
--- /dev/null
+++ b/docs/_locales/zh-TW/ml_on_event_start.md
@@ -0,0 +1,29 @@
+# 當機器學習啟動時
+
+啟動一個 [event handler](/reference/event-handler)（發生某件事情時將會執行的程式的一部分）。 當機器學習模型的預估動作變更為您選擇的動作時，這個處理程式將會執行。
+
+```sig
+ml.onStart(ml.event.Unknown, function () {
+})
+```
+
+機器學習模型每秒鐘會多次更新其預估動作，但是這個事件處理程式只有在當預估動作改變時才會執行。
+
+## 參數
+
+- **事件**：機器學習模型所受訓練的動作其中之一。 特殊值「未知」代表沒有任何動作具有高於辨識點的確定性的情況。
+
+## 範例
+
+當「拍手」動作具有高於辨識點的確定性時，這個範例會在背景中播放音樂旋律。
+
+```blocks
+ml.onStart(ml.event.Clapping, function () {
+    music._playDefaultBackground(music.builtInPlayableMelody(Melodies.Dadadadum), music.PlaybackMode.InBackground)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/zh-TW/ml_on_event_stop.md b/docs/_locales/zh-TW/ml_on_event_stop.md
new file mode 100644
index 0000000..34b9c9f
--- /dev/null
+++ b/docs/_locales/zh-TW/ml_on_event_stop.md
@@ -0,0 +1,31 @@
+# 當機器學習停止時
+
+啟動一個 [event handler](/reference/event-handler)（發生某件事情時將會執行的程式的一部分）。 當機器學習模型的預估動作從您選擇的動作改變時，這個處理程式將會執行。
+
+```sig
+ml.onStop(ml.event.Unknown, function () {
+})
+```
+
+當動作變更時，將會執行前一個動作的停止事件處理程式，然後執行下一個動作的啟動事件處理程式。
+
+例如，如果某個動作的啟動事件處理程式開始在背景播放音樂，則您可以利用停止事件處理程式來停止它。
+
+## 參數
+
+- **事件**：機器學習模型所受訓練的動作其中之一。 特殊值「未知」代表沒有任何動作具有高於辨識點的確定性的情況。
+
+## 範例
+
+當預估動作從「拍手」變更為任何其他動作時，這個範例停止播放音樂旋律。
+
+```blocks
+ml.onStop(ml.event.Clapping, function () {
+    music.stopMelody(MelodyStopOptions.All)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/docs/_locales/zh-TW/ml_on_event_stop_detailed.md b/docs/_locales/zh-TW/ml_on_event_stop_detailed.md
new file mode 100644
index 0000000..903a028
--- /dev/null
+++ b/docs/_locales/zh-TW/ml_on_event_stop_detailed.md
@@ -0,0 +1,33 @@
+# 機器學習停止時
+
+啟動一個 [event handler](/reference/event-handler)（發生某件事情時將會執行的程式的一部分）。 當機器學習模型的預估動作從您選擇的動作改變時，這個處理程式將會執行。
+
+```sig
+ml.onStopDetailed(ml.event.Unknown, function (duration) {
+})
+```
+
+當動作變更時，將會執行前一個動作的停止事件處理程式，然後執行下一個動作的啟動事件處理程式。
+
+例如，如果某個動作的啟動事件處理程式開始在背景播放音樂，則您可以利用停止事件處理程式來停止它。
+
+事件處理程式傳遞一個「duration」參數。 這個 duration（持續時間）是自這個動作成為預估動作以來的 [number](/types/number) 毫秒數。 您可以在您的程式碼中使用 duration 參數，例如顯示該值或用變數記錄總時間。
+
+## 參數
+
+- **事件**：機器學習模型所受訓練的動作其中之一。 特殊值「未知」代表沒有任何動作具有高於辨識點的確定性的情況。
+
+## 範例
+
+此範例在 LED 顯示器上以秒為單位顯示出當預估動作從「拍手」改變成任何其他動作時預估動作為「拍手」有多長的時間。
+
+```blocks
+ml.onStopDetailed(ml.event.Clapping, function (duration) {
+    basic.showNumber(duration / 1000)
+})
+```
+
+```package
+machine-learning-help-stubs=github:microbit-foundation/pxt-microbit-ml-help-stubs#v0.0.1
+machine-learning=github:microbit-foundation/pxt-microbit-ml#v1.0.2
+```
diff --git a/pxt.json b/pxt.json
index 94cf41e..5ea0274 100644
--- a/pxt.json
+++ b/pxt.json
@@ -15,7 +15,56 @@
         "docs/ml_get_event_certainty.md",
         "docs/ml_on_event_start.md",
         "docs/ml_on_event_stop.md",
-        "docs/ml_on_event_stop_detailed.md"
+        "docs/ml_on_event_stop_detailed.md",
+        "_locales/es-ES/machine-learning-jsdoc-strings.json",
+        "_locales/es-ES/machine-learning-strings.json",
+        "docs/_locales/es-ES/ml_get_event_certainty.md",
+        "docs/_locales/es-ES/ml_is_event_detected.md",
+        "docs/_locales/es-ES/ml_on_event_start.md",
+        "docs/_locales/es-ES/ml_on_event_stop_detailed.md",
+        "docs/_locales/es-ES/ml_on_event_stop.md",
+        "_locales/ja/machine-learning-jsdoc-strings.json",
+        "_locales/ja/machine-learning-strings.json",
+        "docs/_locales/ja/ml_get_event_certainty.md",
+        "docs/_locales/ja/ml_is_event_detected.md",
+        "docs/_locales/ja/ml_on_event_start.md",
+        "docs/_locales/ja/ml_on_event_stop_detailed.md",
+        "docs/_locales/ja/ml_on_event_stop.md",
+        "_locales/ko/machine-learning-jsdoc-strings.json",
+        "_locales/ko/machine-learning-strings.json",
+        "docs/_locales/ko/ml_get_event_certainty.md",
+        "docs/_locales/ko/ml_is_event_detected.md",
+        "docs/_locales/ko/ml_on_event_start.md",
+        "docs/_locales/ko/ml_on_event_stop_detailed.md",
+        "docs/_locales/ko/ml_on_event_stop.md",
+        "_locales/nl/machine-learning-jsdoc-strings.json",
+        "_locales/nl/machine-learning-strings.json",
+        "docs/_locales/nl/ml_get_event_certainty.md",
+        "docs/_locales/nl/ml_is_event_detected.md",
+        "docs/_locales/nl/ml_on_event_start.md",
+        "docs/_locales/nl/ml_on_event_stop_detailed.md",
+        "docs/_locales/nl/ml_on_event_stop.md",
+        "_locales/pl/machine-learning-jsdoc-strings.json",
+        "_locales/pl/machine-learning-strings.json",
+        "docs/_locales/pl/ml_get_event_certainty.md",
+        "docs/_locales/pl/ml_is_event_detected.md",
+        "docs/_locales/pl/ml_on_event_start.md",
+        "docs/_locales/pl/ml_on_event_stop_detailed.md",
+        "docs/_locales/pl/ml_on_event_stop.md",
+        "_locales/pt-BR/machine-learning-jsdoc-strings.json",
+        "_locales/pt-BR/machine-learning-strings.json",
+        "docs/_locales/pt-BR/ml_get_event_certainty.md",
+        "docs/_locales/pt-BR/ml_is_event_detected.md",
+        "docs/_locales/pt-BR/ml_on_event_start.md",
+        "docs/_locales/pt-BR/ml_on_event_stop_detailed.md",
+        "docs/_locales/pt-BR/ml_on_event_stop.md",
+        "_locales/zh-TW/machine-learning-jsdoc-strings.json",
+        "_locales/zh-TW/machine-learning-strings.json",
+        "docs/_locales/zh-TW/ml_get_event_certainty.md",
+        "docs/_locales/zh-TW/ml_is_event_detected.md",
+        "docs/_locales/zh-TW/ml_on_event_start.md",
+        "docs/_locales/zh-TW/ml_on_event_stop_detailed.md",
+        "docs/_locales/zh-TW/ml_on_event_stop.md"
     ],
     "testFiles": [
         "autogenerated.ts",
diff --git a/simx/README.md b/simx/README.md
index d32a1d4..f4dadb6 100644
--- a/simx/README.md
+++ b/simx/README.md
@@ -31,14 +31,6 @@ We use react-intl from [FormatJS](https://formatjs.io/) to manage user interface
 
 In development, add strings to `lang/ui.en.json` and run `npm run i18n:compile` to update the strings used by the app.
 
-#### Incorporting changes from Crowdin
-
-Use [update-translations.sh](../bin/update-translations.sh).
-
-Build and download the Crowdin zip and unzip it to a temporary location. Note the zip itself doesn't contain a top-level directory, so on Mac/Linux use e.g. `unzip -d ~/tmp/trans microbit-org.zip`. Run the script passing the directory containing the unzipped translations.
-
-The script will update the UI strings.
-
 #### Updating files in Crowdin
 
 The UI files are updated manually. Please download the existing files and diff locally to ensure the changes are as expected.
diff --git a/simx/bin/update-translations.sh b/simx/bin/update-translations.sh
deleted file mode 100755
index 730848d..0000000
--- a/simx/bin/update-translations.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-#
-# Partial automation of updating translations.
-#
-# New languages adding below and code change in settings.tsx
-# 
-
-set -euxo pipefail
-
-if [ $# -eq 0 ]; then
-  echo Missing argument to extracted Crowdin ZIP >&1
-  exit 1
-fi
-
-languages=""
-
-mkdir -p crowdin/translated
-for language in $languages; do
-    lower="${language,,}"
-    prefix="${1}/${language}/new/apps/makecode-ml-simulator"
-    cp "${prefix}/ui.en.json" "lang/ui.${lower}.json"
-done
-npm run i18n:compile
diff --git a/simx/lang/ui.es-es.json b/simx/lang/ui.es-es.json
new file mode 100644
index 0000000..10c730f
--- /dev/null
+++ b/simx/lang/ui.es-es.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "Evento ML:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "desconocido",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.ja.json b/simx/lang/ui.ja.json
new file mode 100644
index 0000000..f71a503
--- /dev/null
+++ b/simx/lang/ui.ja.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "MLイベント:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "不明",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.ko.json b/simx/lang/ui.ko.json
new file mode 100644
index 0000000..5aef63c
--- /dev/null
+++ b/simx/lang/ui.ko.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "ML 이벤트:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "알 수 없음",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.nl.json b/simx/lang/ui.nl.json
new file mode 100644
index 0000000..9a3a444
--- /dev/null
+++ b/simx/lang/ui.nl.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "ML event:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "onbekend",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.pl.json b/simx/lang/ui.pl.json
new file mode 100644
index 0000000..af8b75a
--- /dev/null
+++ b/simx/lang/ui.pl.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "Wydarzenie ML:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "nieznany",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.pt-br.json b/simx/lang/ui.pt-br.json
new file mode 100644
index 0000000..e249825
--- /dev/null
+++ b/simx/lang/ui.pt-br.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "Evento de ML:",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "desconhecido",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/lang/ui.zh-tw.json b/simx/lang/ui.zh-tw.json
new file mode 100644
index 0000000..498b7df
--- /dev/null
+++ b/simx/lang/ui.zh-tw.json
@@ -0,0 +1,10 @@
+{
+  "select-label": {
+    "defaultMessage": "ML 事件：",
+    "description": "Label for the simulator event select input"
+  },
+  "unknown-event-label": {
+    "defaultMessage": "未知",
+    "description": "Label the default ML event"
+  }
+}
\ No newline at end of file
diff --git a/simx/src/messages/TranslationProvider.tsx b/simx/src/messages/TranslationProvider.tsx
index 4fb151d..f34243b 100644
--- a/simx/src/messages/TranslationProvider.tsx
+++ b/simx/src/messages/TranslationProvider.tsx
@@ -6,6 +6,13 @@
 import { ReactNode } from "react";
 import { IntlProvider, MessageFormatElement } from "react-intl";
 import enMessages from "./ui.en.json";
+import esesMessages from "./ui.es-es.json";
+import jaMessages from "./ui.ja.json";
+import koMessages from "./ui.ko.json";
+import nlMessages from "./ui.nl.json";
+import plMessages from "./ui.pl.json";
+import ptbrMessages from "./ui.pt-br.json";
+import zhtwMessages from "./ui.zh-tw.json";
 
 type Messages = Record<string, string> | Record<string, MessageFormatElement[]>;
 
@@ -23,6 +30,48 @@ const supportedLanguages: Language[] = [
     enName: "English",
     messages: enMessages,
   },
+  {
+    id: "es-es",
+    name: "Español",
+    enName: "Spanish",
+    messages: esesMessages,
+  },
+  {
+    id: "ja",
+    name: "日本語",
+    enName: "Japanese",
+    messages: jaMessages,
+  },
+  {
+    id: "ko",
+    name: "한국어",
+    enName: "Korean",
+    messages: koMessages,
+  },
+  {
+    id: "nl",
+    name: "Nederlands",
+    enName: "Dutch",
+    messages: nlMessages,
+  },
+  {
+    id: "pl",
+    name: "Polski",
+    enName: "Polish",
+    messages: plMessages,
+  },
+  {
+    id: "pt-br",
+    name: "Português (Brasil)",
+    enName: "Portuguese (Brazil)",
+    messages: ptbrMessages,
+  },
+  {
+    id: "zh-tw",
+    name: "繁體中文",
+    enName: "Chinese (Traditional)",
+    messages: zhtwMessages,
+  },
 ];
 
 const getLanguageFromQuery = (): string => {
diff --git a/simx/src/messages/ui.es-es.json b/simx/src/messages/ui.es-es.json
new file mode 100644
index 0000000..7cc3406
--- /dev/null
+++ b/simx/src/messages/ui.es-es.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "Evento ML:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "desconocido"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.ja.json b/simx/src/messages/ui.ja.json
new file mode 100644
index 0000000..a461b20
--- /dev/null
+++ b/simx/src/messages/ui.ja.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "MLイベント:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "不明"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.ko.json b/simx/src/messages/ui.ko.json
new file mode 100644
index 0000000..d3eb58f
--- /dev/null
+++ b/simx/src/messages/ui.ko.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "ML 이벤트:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "알 수 없음"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.nl.json b/simx/src/messages/ui.nl.json
new file mode 100644
index 0000000..4f62131
--- /dev/null
+++ b/simx/src/messages/ui.nl.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "ML event:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "onbekend"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.pl.json b/simx/src/messages/ui.pl.json
new file mode 100644
index 0000000..86fb53a
--- /dev/null
+++ b/simx/src/messages/ui.pl.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "Wydarzenie ML:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "nieznany"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.pt-br.json b/simx/src/messages/ui.pt-br.json
new file mode 100644
index 0000000..568217c
--- /dev/null
+++ b/simx/src/messages/ui.pt-br.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "Evento de ML:"
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "desconhecido"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/simx/src/messages/ui.zh-tw.json b/simx/src/messages/ui.zh-tw.json
new file mode 100644
index 0000000..69821c4
--- /dev/null
+++ b/simx/src/messages/ui.zh-tw.json
@@ -0,0 +1,14 @@
+{
+  "select-label": [
+    {
+      "type": 0,
+      "value": "ML 事件："
+    }
+  ],
+  "unknown-event-label": [
+    {
+      "type": 0,
+      "value": "未知"
+    }
+  ]
+}
\ No newline at end of file