@opengeoweb/sigmet-airmet 9.23.1 → 9.25.0

package/index.esm.js

@@ -3,32 +3,512 @@ import * as React from 'react';
 import React__default from 'react';
 import { FormControlLabel, Radio, Grid, Typography, Box, Button, Checkbox, MenuItem, FormHelperText, useTheme, Dialog, DialogTitle, DialogContent, Card, LinearProgress, List, ListItemButton, Backdrop, CircularProgress } from '@mui/material';
 import { useFormContext } from 'react-hook-form';
-import { useDraftFormHelpers, ReactHookFormRadioGroup, hasValidGeometry, ReactHookFormSelect, ReactHookFormNumberField, isInteger, isValidMax, isValidMin, isEmpty, ReactHookFormDateTime, countIntersectionPoints, hasMulitpleIntersections, ReactHookFormHiddenInput, isMaximumOneDrawing, hasIntersectionWithFIR, isValidGeoJsonCoordinates, isXHoursBefore, isXHoursAfter, ReactHookFormTextField, isLatitude, isNonOrBothCoordinates, isLongitude, ReactHookFormFormControl, isGeometryDirty, ReactHookFormProvider, defaultFormOptions } from '@opengeoweb/form-fields';
+import { FORM_FIELDS_NAMESPACE, useDraftFormHelpers, ReactHookFormRadioGroup, hasValidGeometry, ReactHookFormSelect, ReactHookFormNumberField, isInteger, isValidMax, isValidMin, isEmpty, ReactHookFormDateTime, countIntersectionPoints, hasMulitpleIntersections, ReactHookFormHiddenInput, isMaximumOneDrawing, isValidGeoJsonCoordinates, hasIntersectionWithFIR, isXHoursBefore, isXHoursAfter, ReactHookFormTextField, isLatitude, isNonOrBothCoordinates, isLongitude, ReactHookFormFormControl, isGeometryDirty, ReactHookFormProvider, defaultFormOptions } from '@opengeoweb/form-fields';
 import { useApiContext, useApi, createApiInstance, createNonAuthApiInstance, createFakeApiInstance, ApiProvider } from '@opengeoweb/api';
 import { defaultGeoJSONStyleProperties, defaultIntersectionStyleProperties, defaultPoint, addGeoJSONProperties, defaultBox, defaultPolygon, DRAWMODE, addSelectionTypeToGeoJSON, defaultDelete, getIcon, MapControls, MapViewLayer, useMapDrawTool, addFeatureProperties, rewindGeometry } from '@opengeoweb/webmap-react';
+import i18n from 'i18next';
+import { useTranslation } from 'react-i18next';
 import { dateUtils, ToggleMenu, CustomTooltip, useIsMounted, StatusTag, AlertBanner, ConfirmationServiceProvider, usePreventBrowserClose, useConfirmationDialog, isAxiosError, getAxiosErrorMessage, usePoller, ErrorBoundary } from '@opengeoweb/shared';
+import { LayerManagerMapButtonConnect, LegendMapButtonConnect, MultiDimensionSelectMapButtonsConnect, MapViewConnect, TimeSliderConnect, LegendConnect, LayerManagerConnect } from '@opengeoweb/core';
 import { DrawFIRLand, ChevronLeft, Edit, Success, Clock } from '@opengeoweb/theme';
 import { LayerType, webmapUtils } from '@opengeoweb/webmap';
 import { debounce } from 'lodash';
 import { useDispatch, useSelector, shallowEqual } from 'react-redux';
 import { mapSelectors, syncGroupsActions, mapStoreActions, defaultLayers, syncConstants } from '@opengeoweb/store';
-import { LayerManagerMapButtonConnect, LegendMapButtonConnect, MultiDimensionSelectMapButtonsConnect, MapViewConnect, TimeSliderConnect, LegendConnect, LayerManagerConnect } from '@opengeoweb/core';
-import { useAuthenticationContext } from '@opengeoweb/authentication';
 import { Box as Box$1 } from '@mui/system';
-import 'i18next';
-import 'react-i18next';
+import { useAuthenticationContext } from '@opengeoweb/authentication';
 
 var en = {
-	"sigmet-airmet": "sigmet"
+	"sigmet-airmet": "sigmet",
+	levels: "Levels",
+	"not-published": "(Not published)",
+	"valid-time": "Valid time",
+	"vulcanic-ash-description": "Use the FIR to indicate the direction the Volcanic Ash is moving to",
+	"vulcanic-VA-SIGMET-text": "Cancel VA SIGMET without VA MOV TO information",
+	"vulcanic-cloud-moving-text": "Volcanic Cloud is moving in the direction of",
+	unknown: "Unknown",
+	"create-new-product": "Create a new {{ product }}",
+	discard: "DISCARD",
+	save: "Save",
+	cancel: "Cancel",
+	publish: "Publish",
+	back: "BACK",
+	draft: "DRAFT",
+	"error-title": "Something went wrong with loading the configuration file",
+	"error-auth-login": "This feature is protected by authentication. Please log in to proceed",
+	"error-config": "An error has occurred while loading the config",
+	"error-backend": "An error has occurred while retrieving the list, please try again",
+	"error-auth": "This feature is protected by authentication",
+	"saved-as-draft": "saved as draft",
+	cancels: "Cancels",
+	close: "Close",
+	"discard-non-capitalized": "Discard",
+	"are-you-sure-you-want-to-discard": "Are you sure you would like to discard this {{product}}? Its properties will be lost`",
+	"save-changes-made": "Do you want to save any changes made?",
+	"publish-this-product": "Are you sure you want to publish this {{product}}?",
+	"cancel-this-product": "Are you sure you want to cancel this {{product}}?`",
+	"save-and-close": "Save and close",
+	"discard-and-close": "Discard and close",
+	"drop-a-point-as": "Drop a point as {{type}} position`",
+	"draw-a-box-as": "Draw a box as {{type}} position",
+	"draw-a-shape-as": "Draw a shape as {{type}} position`",
+	"set-a-fir-as": "Set FIR as {{type}} position`",
+	"remove-geometry": "Remove geometry",
+	"valid-until-time": "Valid until time has to be after Valid from time",
+	"discard-product": "Discard {{product}}",
+	"issue-time": "Issue time",
+	"type-title": "Type",
+	"phenomenon-title": "What",
+	"observation-label": "Observed",
+	"forecast-label": "Forecast",
+	"valid-from-before-current-error": "Valid from time cannot be before current time",
+	"valid-from-time-error": "Valid from time can be no more than {{hours}} hours after current time",
+	"date-and-time": "Date and time",
+	"valid-from": "Valid from",
+	"valid-until": "Valid until",
+	"valid-until-time-error": "Valid until time can be no more than {{hours}} hours after Valid from time",
+	"select-fir-title": "Where",
+	"select-fir-label": "Select FIR",
+	"geometry-coodinates-empty-message": "A start position drawing is required",
+	"geometry-no-intersection-message": "The start position needs to be (partly) inside the FIR",
+	"geometry-exit-draw-mode-message": "Press ESC to exit draw mode",
+	"geometry-max-feature-points-message": "Intersection of the drawn polygon with the FIR-boundary has more than 6 individual points. Check if the TAC in the preview corresponds to the intended area.",
+	"geometry-multi-intersections-message": "The drawn polygon has multiple intersections with the FIR-boundary. The drawn polygon will be used for the TAC-code.",
+	"geometry-maximum-points-message": "The start position drawing allows a maximum of {{maxPoints}} individual points",
+	"geometry-more-than-6-points-message": "The start/end position drawing has exceeded 6 individual points. The TAC has a total of {{totalDrawnPoints}} points. If possible, reduce the number of points.",
+	"geometry-intersection-above-6-points-message": "The start/end position of the intersected polygon has {{intersectingPolygonPointsTotal}} points, and the intersection of the drawn polygon with the FIR-boundary has exceeded 6 individual points. Check if the TAC in the preview corresponds to the intended area.",
+	"geometry-only-one-start-position-drawing": "Only one start position drawing is allowed",
+	"progress-get-movement-step-valktmessage": "Speed should be rounded to the nearest {{value}}kt",
+	"progress-get-movement-step-valkmhmessage": "Speed should be rounded to the nearest {{value}}kmh",
+	"progress-coordinate-empty-message": "An end position drawing is required when selecting End position",
+	"progress-no-intersection-message": "The end position needs to be (partly) inside the FIR",
+	"invalid-unit": "Invalid unit",
+	"progress-maximumPointsMessage": "The end position drawing allows a maximum of {{maxPoints}} individual points",
+	"progress-more-than-6-points-message": "The start/end position drawing has exceeded 6 individual points. The TAC has a total of {{totalDrawnPoints}} points. If possible, reduce the number of points.",
+	"progress-intersection-above-6-points-message": "The start/end position of the intersected polygon has {{intersectingPolygonPointsTotal}} points, and the intersection of the drawn polygon with the FIR-boundary has exceeded 6 individual points. Check if the TAC in the preview corresponds to the intended area.",
+	"progress-radio-button-label-no-va-exp": "No volcanic ash expected",
+	"progress-radio-button-label-stationary": "Stationary",
+	"progress-radio-button-label-movement": "Movement",
+	"progress-radio-button-label-end-potision": "End position",
+	"progress-movement-direction-label": "Set direction",
+	"progress-movement-unit-label": "Unit",
+	"progress-movement-speed-label": "Step speed",
+	"progress-the-minimum-level-in-movement": "The minimum level in {{movementUnitType}} is {{movementUnit}}",
+	"progress-the-maxium-level-in-movement": "The maximum level in {{movementUnitType}} is {{movementUnit}}",
+	"progress-only-one-position-drawing": "Only one end position drawing is allowed",
+	at: "At",
+	select: "Select",
+	"observation-forecast-error": "Observation time cannot be in the future",
+	"start-position": "Start position",
+	between: "Between",
+	above: "Above",
+	change: "Change",
+	weakening: "Weakening",
+	"no-change": "No change",
+	intensifying: "Intensifying",
+	"issued-at": "Issued at",
+	"volcano-name": "Volcano name",
+	latitude: "Latitude",
+	longitude: "Longitude",
+	"tac-missing-data": "Missing data: no TAC can be generated",
+	"invalid-surface-wind-direction-message": "Direction must be rounded to the nearest {{value}} deg.",
+	"surface-wind-label": "wind direction",
+	"surface-wind-speed-label": "speed",
+	"surface-wind-helper-text": "Value in degrees",
+	"surface-wind-rule-min-max-message": "Direction should be between 10 and 360 deg.",
+	"surface-wind-minimum-wind-speed": "The minimum wind speed in {{windUnit}} is {{minWindSpeedValue}}",
+	"surface-wind-maximum-wind-speed": "The maximum wind speed in {{windUnit}} is {{maxWindSpeedValue}}",
+	"invalid-surface-visibility-till-750-steps-message": "A visibility below 750m must be rounded to the nearest {{value}}m",
+	"invalid-surface-visibility-from-750-steps-message": "A visibility above 750m must be rounded to the nearest {{value}}m",
+	set: "Set",
+	"levels-get-level-invalid-steps-for-fl-unit-message": "Levels must be rounded to the nearest {{value}}",
+	"levels-get-level-invalid-steps-for-ft-unit-message": "Levels must be rounded to the nearest {{value}}ft",
+	"levels-get-level-invalid-steps-for-m-unit-message": "Levels must be rounded to the nearest {{value}}m",
+	"levels-invalid-unit-message": "Level unit not defined",
+	"levels-invalid-level-unit-combination-message": "Invalid unit combination",
+	level: "Level",
+	"levels-the-minimum-level": "The minimum level in {{levelUnit}} is {{minLevelValue}}",
+	"levels-the-maximum-level": "The maximum level in {{levelUnit}} is {{maxLevelValue}}",
+	"levels-upper-level-label": "Upper level",
+	"unit-label": "Unit",
+	"levels-lower-level-label": "Lower level",
+	"levels-tops-label": "Tops",
+	progress: "Progress",
+	"surface-visibility": "Visibility",
+	"surface-visibility-cause": "Cause",
+	"surface-visibility-minimum-visibility": "The minimum visibility in meters is {{minimumVisibility}}",
+	"surface-visibility-maximum-visibility": "The maximum visibility in meters is {{maximumVisibility}}",
+	"surface-visibility-helper-text": "Value in meters",
+	phenomenon: "Phenomenon"
 };
 var fi = {
-	"sigmet-airmet": "sigmet"
+	"sigmet-airmet": "sigmet",
+	levels: "Tasot",
+	"not-published": "(Ei julkaistu)",
+	"valid-time": "Voimassa oleva aika",
+	"vulcanic-ash-description": "Käytä FIR:iä määrittääksesi suunnan johon vulkaaninen tuhkapilvi on liikkumassa",
+	"vulcanic-VA-SIGMET-text": "Peruuta VA SIGMET ilman VA MOV TO tietoja",
+	"vulcanic-cloud-moving-text": "Vulkaaninen tuhkapilvi on liikkumassa suuntaan: ",
+	unknown: "Ei tiedossa",
+	"create-new-product": "Luo uusi {{product}}",
+	discard: "HYLKÄÄ",
+	save: "Tallenna",
+	cancel: "Peruuta",
+	publish: "Julkaise",
+	back: "PALAA TAKAISIN",
+	draft: "LUONNOS",
+	"error-title": "Virhe konfiguraatiotiedostoa ladatessa",
+	"error-auth-login": "Tämän toiminnallisuuden käyttäminen vaatii tunnistautumista. Kirjaudu sisään jatkaaksesi",
+	"error-config": "Konfiguraatiota ladatessa on havaittu virhe",
+	"error-backend": "Tietoja haettaessa on havaittu virhe, yritä uudelleen",
+	"error-auth": "Tämän toiminnallisuuden käyttäminen vaatii tunnistautumista",
+	"saved-as-draft": "tallenna luonnoksena",
+	cancels: "Peruu",
+	close: "Sulje",
+	"discard-non-capitalized": "Hylkää",
+	"are-you-sure-you-want-to-discard": "Oletko varma, että haluat hylätä kyseisen {{product}}? Kaikki ilmoitetut tiedot menetetään",
+	"save-changes-made": "Haluatko tallentaa kaikki tehdyt muutokset?",
+	"publish-this-product": "Oletko varma, että haluat julkaista tämän {{product}}:n?",
+	"cancel-this-product": "Oletko varma, että haluat peruuttaa tämän {{product}}:n?",
+	"save-and-close": "Tallenna ja sulje",
+	"discard-and-close": "Hylkää ja sulje",
+	"drop-a-point-as": "Pudota piste kartalle ja käytä sitä {{type}} sijaintina ",
+	"draw-a-box-as": "Piirrä laatikko kartalle ja käytä sitä {{type}} sijaintina",
+	"draw-a-shape-as": "Piirrä muoto kartalle ja käytä sitä {{type}} sijaintina",
+	"set-a-fir-as": "Aseta FIR {{type}}:n sijaintina",
+	"remove-geometry": "Poista geometria",
+	"valid-until-time": "Voimassaoloajan päättymishetken on oltava voimassaoloajan alkuhetken jälkeen",
+	"discard-product": "Hylkää {{product}}",
+	"issue-time": "Julkaisuaika",
+	"type-title": "Tyyppi",
+	"phenomenon-title": "Mikä",
+	"observation-label": "Havainto",
+	"forecast-label": "Ennuste",
+	"valid-from-before-current-error": "Voimassaoloajan alkuhetki ei voi olla ennen nykyistä ajanhetkeä.",
+	"valid-from-time-error": "Voimassaoloajan alkuhetki ei voi olla enempää kuin {{hours}} nykyisen ajanhetken jälkeen.",
+	"date-and-time": "Päivämäärä ja aika",
+	"valid-from": "Alkuhetki",
+	"valid-until": "Päättymishetki",
+	"valid-until-time-error": "Voimassaoloajan loppuhetki ei voi olla enempää kuin {{hours}} voimassaoloajan alkuhetken jälkeen.",
+	"select-fir-title": "Missä",
+	"select-fir-label": "Valitse FIR",
+	"geometry-coodinates-empty-message": "Aloituspaikan piirros vaaditaan",
+	"geometry-no-intersection-message": "Aloituspaikan sijainnin on oltava ainakin osittain FIR:n sisäpuolella.",
+	"geometry-exit-draw-mode-message": "Paina ESC:iä poistuaksesi piirtotilasta",
+	"geometry-max-feature-points-message": "Piirretyn polygonin ja FIR-rajan leikkauspisteessä on yli 6 yksittäistä pistettä. Tarkita vastaako esikatselun TAC aiottua aluetta.",
+	"geometry-multi-intersections-message": "Piirretyllä polygonilla on useita leikkauspisteitä FIR-rajan kanssa. Piirrettyä polygonia käytetään TAC-koodin luomiseen",
+	"geometry-maximum-points-message": "Aloituspisteenä käytettävä piirros sallii maksimissaan {{maxPoints}} yksittäistä pistettä.",
+	"geometry-more-than-6-points-message": "Piirros jota käytetään sijainnin aloitukseen tai lopetukseen sisältää enemmän kuin sallitun määrän: 6 yksittäistä pistettä. TAC-viestissä on kaikenkaikkiaan {{totalDrawnPoints}} pistettä. Jos mahdollista, vähennä pisteiden määrää.",
+	"geometry-intersection-above-6-points-message": "Leikatun polygonin alku-/päätepisteessä on {{intersectingPolygonPointsTotal}} pistettä. Piirretyn polygonin ja FIR-rajan leikkauspiste on ylittänyt 6 yksittäistä pistettä. Tarkista vastaako esikatselun TAC aiottua aluetta.",
+	"geometry-only-one-start-position-drawing": "Vain yksi aloitusaluepiirros on sallittu.",
+	"progress-get-movement-step-valktmessage": "Nopeus tulisi pyöristää lähimpään {{value}}kt arvoon.",
+	"progress-get-movement-step-valkmhmessage": "Nopeus tulisi pyöristää lähimpään {{value}}kmh arvoon.",
+	"progress-coordinate-empty-message": "Lopetuspaikan piirtäminen on pakollista, kun valitset lopetuspaikan",
+	"progress-no-intersection-message": "Lopetuspaikan täytyy olla (osittain) FIR-alueen sisällä.",
+	"invalid-unit": "Virheellinen yksikkö",
+	"progress-maximumPointsMessage": "Lopetuspaikan piirtäminen sallii enintään {{maxPoints}} yksittäistä pistettä.",
+	"progress-more-than-6-points-message": "Aloitus-/lopetuspaikan piirroksessa on yli 6 yksittäistä pistettä. TAC:ssa on kaikenkaikkiaan {{totalDrawnPoints}} pistettä. Vähennä pisteiden määrää, jos mahdollista.",
+	"progress-intersection-above-6-points-message": "Leikatun polygonin aloitus-/lopetuspaikassa on {{intersectingPolygonPointsTotal}} pistettä. Piirretyn monikulmion leikkaus FIR-rajalla on ylittänyt 6 yksittäistä pistettä. Tarkista, vastaako esikatselun TAC aiottua aluetta.",
+	"progress-radio-button-label-no-va-exp": "Tulivuoren tuhkaa ei odotettavissa",
+	"progress-radio-button-label-stationary": "Liikkumaton",
+	"progress-radio-button-label-movement": "Liikkuva",
+	"progress-radio-button-label-end-potision": "Lopullinen sijainti",
+	"progress-movement-direction-label": "Aseta suunta",
+	"progress-movement-unit-label": "Yksikkö",
+	"progress-movement-speed-label": "Askeleen nopeus",
+	"progress-the-minimum-level-in-movement": "Pienin taso {{movementUnitType}}:ssa on {{movementUnit}}",
+	"progress-the-maxium-level-in-movement": "Suurin taso {{movementUnitType}}:ssa on {{movementUnit}}",
+	"progress-only-one-position-drawing": "Vain yksi lopetuspaikan piirros on sallittu",
+	at: "Ajanhetkessä",
+	select: "Valitse",
+	"observation-forecast-error": "Havainnon ajankohta ei voi olla tulevaisuudessa",
+	"start-position": "Alkusijainti",
+	between: "Välissä",
+	above: "Yläpuolella",
+	change: "Muutos",
+	weakening: "Heikentyvä",
+	"no-change": "Ei muutosta",
+	intensifying: "Vahvistuva",
+	"issued-at": "Annettu klo:",
+	"volcano-name": "Tulivuoren nimi",
+	latitude: "Leveysaste",
+	longitude: "Pituusaste",
+	"tac-missing-data": "Tarvittavia tietoja puuttu, TAC:ia ei voida generoida",
+	"invalid-surface-wind-direction-message": "Suunta tulee pyöristää lähimpään {{value}} asteeseen.",
+	"surface-wind-label": "tuulen suunta",
+	"surface-wind-speed-label": "nopeus",
+	"surface-wind-helper-text": "Arvo asteina",
+	"surface-wind-rule-min-max-message": "Suunnan on oltava 10 ja 360 asteen välissä.",
+	"surface-wind-minimum-wind-speed": "Minimituulennopeus käyttäen yksikköä {{windUnit}} on {{minWindSpeedValue}}",
+	"surface-wind-maximum-wind-speed": "Maksimituulennopeus käyttäen yksikköä {{windUnit}} on {{maxWindSpeedValue}}",
+	"invalid-surface-visibility-till-750-steps-message": "Alle 750m näkyvyys tulee pyöristää lähimpään {{value}}m arvoon.",
+	"invalid-surface-visibility-from-750-steps-message": "Yli 750m näkyvyys tulee pyöristää lähimpään {{value}}m arvoon.",
+	set: "Aseta",
+	"levels-get-level-invalid-steps-for-fl-unit-message": "Tasot tulee pyöristää lähimpään {{value}} arvoon.",
+	"levels-get-level-invalid-steps-for-ft-unit-message": "Tasot tulee pyöristää lähimpään {{value}}ft arvoon.",
+	"levels-get-level-invalid-steps-for-m-unit-message": "Tasot tulee pyöristää lähimpään {{value}}m arvoon",
+	"levels-invalid-unit-message": "Tason yksikkö ei ole määritelty",
+	"levels-invalid-level-unit-combination-message": "Virheellinen yhdistelmä yksiköitä",
+	level: "Taso",
+	"levels-the-maximum-level": "Tason maksimiarvo käyttäen yksikköä {{levelUnit}} on {{maxLevelValue}}",
+	"levels-the-minimum-level": "Tason minimiarvo käyttäen yksiköä {{levelUnit}} on {{minLevelValue}} ",
+	"levels-upper-level-label": "Ylempi taso",
+	"unit-label": "Yksikkö",
+	"levels-lower-level-label": "Alempi taso",
+	"levels-tops-label": "Ylittää",
+	progress: "Edistyminen",
+	"surface-visibility": "Näkyvyys",
+	"surface-visibility-cause": "Aiheuttaja",
+	"surface-visibility-minimum-visibility": "Miniminäkyvyys metreinä: {{minimumVisibility}}",
+	"surface-visibility-maximum-visibility": "Maksiminäkyvyys metreinä: {{maximumVisibility}}",
+	"surface-visibility-helper-text": "Arvo metreinä",
+	phenomenon: "sääilmiö"
 };
 var no = {
-	"sigmet-airmet": "sigmet"
+	"sigmet-airmet": "sigmet",
+	levels: "Nivå",
+	"not-published": "Ikke publisert",
+	"valid-time": "ikke oversatt",
+	"vulcanic-ash-description": "Bruk FIR til å indikere retningen den vulkansek asken går mot",
+	"vulcanic-VA-SIGMET-text": "ikke oversatt",
+	"vulcanic-cloud-moving-text": "Vulkansk askesky går mot",
+	unknown: "Ukjent",
+	"create-new-product": "Lage et nytt {{ product }}",
+	discard: "ikke oversatt",
+	save: "ikke oversatt",
+	cancel: "ikke oversatt",
+	publish: "ikke oversatt",
+	back: "ikke oversatt",
+	draft: "ikke oversatt",
+	"error-title": "ikke oversatt",
+	"error-auth-login": "ikke oversatt",
+	"error-config": "ikke oversatt",
+	"error-backend": "ikke oversatt",
+	"error-auth": "ikke oversatt",
+	"saved-as-draft": "ikke oversatt",
+	cancels: "ikke oversatt",
+	close: "ikke oversatt",
+	"discard-non-capitalized": "ikke oversatt",
+	"are-you-sure-you-want-to-discard": "ikke oversatt",
+	"save-changes-made": "ikke oversatt",
+	"publish-this-product": "ikke oversatt",
+	"cancel-this-product": "ikke oversatt",
+	"save-and-close": "ikke oversatt",
+	"discard-and-close": "ikke oversatt",
+	"drop-a-point-as": "ikke oversatt",
+	"draw-a-box-as": "ikke oversatt",
+	"draw-a-shape-as": "ikke oversatt",
+	"set-a-fir-as": "ikke oversatt",
+	"remove-geometry": "ikke oversatt",
+	"valid-until-time": "ikke oversatt",
+	"discard-product": "ikke oversatt",
+	"issue-time": "ikke oversatt",
+	"type-title": "ikke oversatt",
+	"phenomenon-title": "ikke oversatt",
+	"observation-label": "ikke oversatt",
+	"forecast-label": "ikke oversatt",
+	"valid-from-before-current-error": "ikke oversatt",
+	"valid-from-time-error": "ikke oversatt",
+	"date-and-time": "ikke oversatt",
+	"valid-from": "ikke oversatt",
+	"valid-until": "ikke oversatt",
+	"valid-until-time-error": "ikke oversatt",
+	"select-fir-title": "ikke oversatt",
+	"select-fir-label": "ikke oversatt",
+	"geometry-coodinates-empty-message": "ikke oversatt",
+	"geometry-no-intersection-message": "ikke oversatt",
+	"geometry-exit-draw-mode-message": "ikke oversatt",
+	"geometry-max-feature-points-message": "ikke oversatt",
+	"geometry-multi-intersections-message": "ikke oversatt",
+	"geometry-maximum-points-message": "ikke oversatt",
+	"geometry-more-than-6-points-message": "ikke oversatt",
+	"geometry-intersection-above-6-points-message": "ikke oversatt",
+	"geometry-only-one-start-position-drawing": "ikke oversatt",
+	"progress-get-movement-step-valktmessage": "ikke oversatt",
+	"progress-get-movement-step-valkmhmessage": "ikke oversatt",
+	"progress-coordinate-empty-message": "ikke oversatt",
+	"progress-no-intersection-message": "ikke oversatt",
+	"invalid-unit": "ikke oversatt",
+	"progress-maximumPointsMessage": "ikke oversatt",
+	"progress-more-than-6-points-message": "ikke oversatt",
+	"progress-intersection-above-6-points-message": "ikke oversatt",
+	"progress-radio-button-label-no-va-exp": "ikke oversatt",
+	"progress-radio-button-label-stationary": "ikke oversatt",
+	"progress-radio-button-label-movement": "ikke oversatt",
+	"progress-radio-button-label-end-potision": "ikke oversatt",
+	"progress-movement-direction-label": "ikke oversatt",
+	"progress-movement-unit-label": "ikke oversatt",
+	"progress-movement-speed-label": "ikke oversatt",
+	"progress-the-minimum-level-in-movement": "ikke oversatt",
+	"progress-the-maxium-level-in-movement": "ikke oversatt",
+	"progress-only-one-position-drawing": "ikke oversatt",
+	at: "ikke oversatt",
+	select: "ikke oversatt",
+	"observation-forecast-error": "ikke oversatt",
+	"start-position": "ikke oversatt",
+	between: "ikke oversatt",
+	above: "ikke oversatt",
+	change: "ikke oversatt",
+	weakening: "ikke oversatt",
+	"no-change": "ikke oversatt",
+	intensifying: "ikke oversatt",
+	"issued-at": "ikke oversatt",
+	"volcano-name": "ikke oversatt",
+	latitude: "ikke oversatt",
+	longitude: "ikke oversatt",
+	"tac-missing-data": "ikke oversatt",
+	"invalid-surface-wind-direction-message": "ikke oversatt",
+	"surface-wind-label": "ikke oversatt",
+	"surface-wind-speed-label": "ikke oversatt",
+	"surface-wind-helper-text": "ikke oversatt",
+	"surface-wind-rule-min-max-message": "ikke oversatt",
+	"surface-wind-minimum-wind-speed": "ikke oversatt",
+	"surface-wind-maximum-wind-speed": "ikke oversatt",
+	"invalid-surface-visibility-till-750-steps-message": "ikke oversatt",
+	"invalid-surface-visibility-from-750-steps-message": "ikke oversatt",
+	set: "ikke oversatt",
+	"levels-get-level-invalid-steps-for-fl-unit-message": "ikke oversatt",
+	"levels-get-level-invalid-steps-for-ft-unit-message": "ikke oversatt",
+	"levels-get-level-invalid-steps-for-m-unit-message": "ikke oversatt",
+	"levels-invalid-unit-message": "ikke oversatt",
+	"levels-invalid-level-unit-combination-message": "ikke oversatt",
+	level: "ikke oversatt",
+	"levels-the-minimum-level": "ikke oversatt",
+	"levels-the-maximum-level": "ikke oversatt",
+	"levels-upper-level-label": "ikke oversatt",
+	"unit-label": "ikke oversatt",
+	"levels-lower-level-label": "ikke oversatt",
+	"levels-tops-label": "ikke oversatt",
+	progress: "ikke oversatt",
+	"surface-visibility": "ikke oversatt",
+	"surface-visibility-cause": "ikke oversatt",
+	"surface-visibility-minimum-visibility": "ikke oversatt",
+	"surface-visibility-maximum-visibility": "ikke oversatt",
+	"surface-visibility-helper-text": "ikke oversatt",
+	phenomenon: "ikke oversatt"
 };
 var nl = {
-	"sigmet-airmet": "sigmet"
+	"sigmet-airmet": "sigmet",
+	levels: "niet vertaald",
+	"not-published": "niet vertaald",
+	"valid-time": "niet vertaald",
+	"vulcanic-ash-description": "niet vertaald",
+	"vulcanic-VA-SIGMET-text": "niet vertaald",
+	"vulcanic-cloud-moving-text": "niet vertaald",
+	unknown: "niet vertaald",
+	"create-new-product": "niet vertaald",
+	discard: "niet vertaald",
+	save: "niet vertaald",
+	cancel: "niet vertaald",
+	publish: "niet vertaald",
+	back: "niet vertaald",
+	draft: "niet vertaald",
+	"error-title": "niet vertaald",
+	"error-auth-login": "niet vertaald",
+	"error-config": "niet vertaald",
+	"error-backend": "niet vertaald",
+	"error-auth": "niet vertaald",
+	"saved-as-draft": "niet vertaald",
+	cancels: "niet vertaald",
+	close: "niet vertaald",
+	"discard-non-capitalized": "niet vertaald",
+	"are-you-sure-you-want-to-discard": "niet vertaald",
+	"save-changes-made": "niet vertaald",
+	"publish-this-product": "niet vertaald",
+	"cancel-this-product": "niet vertaald",
+	"save-and-close": "niet vertaald",
+	"discard-and-close": "niet vertaald",
+	"drop-a-point-as": "niet vertaald",
+	"draw-a-box-as": "niet vertaald",
+	"draw-a-shape-as": "niet vertaald",
+	"set-a-fir-as": "niet vertaald",
+	"remove-geometry": "niet vertaald",
+	"valid-until-time": "niet vertaald",
+	"discard-product": "niet vertaald",
+	"issue-time": "niet vertaald",
+	"type-title": "niet vertaald",
+	"phenomenon-title": "niet vertaald",
+	"observation-label": "niet vertaald",
+	"forecast-label": "niet vertaald",
+	"valid-from-before-current-error": "niet vertaald",
+	"valid-from-time-error": "niet vertaald",
+	"date-and-time": "niet vertaald",
+	"valid-from": "niet vertaald",
+	"valid-until": "niet vertaald",
+	"valid-until-time-error": "niet vertaald",
+	"select-fir-title": "niet vertaald",
+	"select-fir-label": "niet vertaald",
+	"geometry-coodinates-empty-message": "niet vertaald",
+	"geometry-no-intersection-message": "niet vertaald",
+	"geometry-exit-draw-mode-message": "niet vertaald",
+	"geometry-max-feature-points-message": "niet vertaald",
+	"geometry-multi-intersections-message": "niet vertaald",
+	"geometry-maximum-points-message": "niet vertaald",
+	"geometry-more-than-6-points-message": "niet vertaald",
+	"geometry-intersection-above-6-points-message": "niet vertaald",
+	"geometry-only-one-start-position-drawing": "niet vertaald",
+	"progress-get-movement-step-valktmessage": "niet vertaald",
+	"progress-get-movement-step-valkmhmessage": "niet vertaald",
+	"progress-coordinate-empty-message": "niet vertaald",
+	"progress-no-intersection-message": "niet vertaald",
+	"invalid-unit": "niet vertaald",
+	"progress-maximumPointsMessage": "niet vertaald",
+	"progress-more-than-6-points-message": "niet vertaald",
+	"progress-intersection-above-6-points-message": "niet vertaald",
+	"progress-radio-button-label-no-va-exp": "niet vertaald",
+	"progress-radio-button-label-stationary": "niet vertaald",
+	"progress-radio-button-label-movement": "niet vertaald",
+	"progress-radio-button-label-end-potision": "niet vertaald",
+	"progress-movement-direction-label": "niet vertaald",
+	"progress-movement-unit-label": "niet vertaald",
+	"progress-movement-speed-label": "niet vertaald",
+	"progress-the-minimum-level-in-movement": "niet vertaald",
+	"progress-the-maxium-level-in-movement": "niet vertaald",
+	"progress-only-one-position-drawing": "niet vertaald",
+	at: "niet vertaald",
+	select: "niet vertaald",
+	"observation-forecast-error": "niet vertaald",
+	"start-position": "niet vertaald",
+	between: "niet vertaald",
+	above: "niet vertaald",
+	change: "niet vertaald",
+	weakening: "niet vertaald",
+	"no-change": "niet vertaald",
+	intensifying: "niet vertaald",
+	"issued-at": "niet vertaald",
+	"volcano-name": "niet vertaald",
+	latitude: "niet vertaald",
+	longitude: "niet vertaald",
+	"tac-missing-data": "niet vertaald",
+	"invalid-surface-wind-direction-message": "niet vertaald",
+	"surface-wind-label": "niet vertaald",
+	"surface-wind-speed-label": "niet vertaald",
+	"surface-wind-helper-text": "niet vertaald",
+	"surface-wind-rule-min-max-message": "niet vertaald",
+	"surface-wind-minimum-wind-speed": "niet vertaald",
+	"surface-wind-maximum-wind-speed": "niet vertaald",
+	"invalid-surface-visibility-till-750-steps-message": "niet vertaald",
+	"invalid-surface-visibility-from-750-steps-message": "niet vertaald",
+	set: "niet vertaald",
+	"levels-get-level-invalid-steps-for-fl-unit-message": "niet vertaald",
+	"levels-get-level-invalid-steps-for-ft-unit-message": "niet vertaald",
+	"levels-get-level-invalid-steps-for-m-unit-message": "niet vertaald",
+	"levels-invalid-unit-message": "niet vertaald",
+	"levels-invalid-level-unit-combination-message": "niet vertaald",
+	level: "niet vertaald",
+	"levels-the-minimum-level": "niet vertaald",
+	"levels-the-maximum-level": "niet vertaald",
+	"levels-upper-level-label": "niet vertaald",
+	"unit-label": "niet vertaald",
+	"levels-lower-level-label": "niet vertaald",
+	"levels-tops-label": "niet vertaald",
+	progress: "niet vertaald",
+	"surface-visibility": "niet vertaald",
+	"surface-visibility-cause": "niet vertaald",
+	"surface-visibility-minimum-visibility": "niet vertaald",
+	"surface-visibility-maximum-visibility": "niet vertaald",
+	"surface-visibility-helper-text": "niet vertaald",
+	phenomenon: "niet vertaald"
 };
 var sigmetAirmetTranslations = {
 	en: en,
@@ -2069,10 +2549,20 @@ const useShortTestHelpers = () => {
   };
 };
 
+const SA_NAMESPACE = 'sigmetairmet';
+const ns = [SA_NAMESPACE, FORM_FIELDS_NAMESPACE];
+const translateKeyOutsideComponents = (key, params = undefined) => i18n.t(key, Object.assign({
+  ns
+}, params));
+const useSigmetAirmetTranslation = () => useTranslation(ns);
+
 const Change = ({
   isDisabled,
   isReadOnly
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     isRequired: isRequiredField
   } = useDraftFormHelpers();
@@ -2082,7 +2572,7 @@ const Change = ({
   const isRequired = value => isShortTest() || isRequiredField(value);
   const fieldsDisabled = isDisabled || isShortTest();
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Change",
+    title: t('change'),
     sx: styles$2.containerItem
   }, {
     children: jsx(Grid, Object.assign({
@@ -2101,17 +2591,17 @@ const Change = ({
       }, {
         children: [jsx(RadioButtonAndLabel, {
           value: "WKN",
-          label: "Weakening",
+          label: t('weakening'),
           disabled: fieldsDisabled,
           "data-testid": "change-WKN"
         }), jsx(RadioButtonAndLabel, {
           value: "NC",
-          label: "No change",
+          label: t('no-change'),
           disabled: fieldsDisabled,
           "data-testid": "change-NC"
         }), jsx(RadioButtonAndLabel, {
           value: "INTSF",
-          label: "Intensifying",
+          label: t('intensifying'),
           disabled: fieldsDisabled,
           "data-testid": "change-INTSF"
         })]
@@ -2621,12 +3111,12 @@ const getDialogtitle = (product, productType) => {
   }
   if (!isInstanceOfCancelSigmetOrAirmet(product)) {
     const phenomenon = productType === 'sigmet' ? SigmetPhenomena[product.phenomenon] : AirmetPhenomena[product.phenomenon];
-    return `${productName} ${phenomenon} - ${product.status === 'DRAFT' ? 'saved as draft' : ProductStatusDescription[product.status]}`;
+    return `${productName} ${phenomenon} - ${product.status === 'DRAFT' ? translateKeyOutsideComponents('saved-as-draft') : ProductStatusDescription[product.status]}`;
   }
   if (isInstanceOfCancelSigmet(product)) {
-    return `${productName} Cancels ${product.cancelsSigmetSequenceId}`;
+    return `${productName} ${translateKeyOutsideComponents('cancels')} ${product.cancelsSigmetSequenceId}`;
   }
-  return `${productName} Cancels ${product.cancelsAirmetSequenceId}`;
+  return `${productName} ${translateKeyOutsideComponents('cancels')} ${product.cancelsAirmetSequenceId}`;
 };
 const getProductFormMode = (canBeOptions, productListItem) => {
   if (productListItem === null) {
@@ -2651,17 +3141,17 @@ const getProductFormLifecycleButtons = ({
   const hasPublishButton = canBe.includes('PUBLISHED');
   const onPublish = () => onButtonPress('PUBLISHED');
   const mobileMenuItems = [...(hasDiscardButton ? [{
-    text: 'Discard',
+    text: translateKeyOutsideComponents('discard'),
     action: onDiscard
   }] : []), ...(hasSaveButton ? [{
-    text: 'Save',
+    text: translateKeyOutsideComponents('save'),
     action: onSave,
     isDisabled: _areActionsDisabled
   }] : []), ...(hasCancelButton ? [{
-    text: 'Cancel',
+    text: translateKeyOutsideComponents('cancel'),
     action: onCancel
   }] : []), ...(hasPublishButton ? [{
-    text: 'Publish',
+    text: translateKeyOutsideComponents('publish'),
     action: onPublish,
     isDisabled: _areActionsDisabled
   }] : [])];
@@ -2686,7 +3176,7 @@ const getProductFormLifecycleButtons = ({
         sx: buttonStyle,
         "data-testid": "productform-dialog-discard"
       }, {
-        children: "DISCARD"
+        children: translateKeyOutsideComponents('discard')
       })), hasSaveButton && jsx(Button, Object.assign({
         variant: "tertiary",
         onClick: onSave,
@@ -2694,14 +3184,14 @@ const getProductFormLifecycleButtons = ({
         "data-testid": "productform-dialog-draft",
         disabled: _areActionsDisabled
       }, {
-        children: "Save"
+        children: translateKeyOutsideComponents('save')
       })), hasCancelButton && jsx(Button, Object.assign({
         variant: "tertiary",
         onClick: onCancel,
         sx: buttonStyle,
         "data-testid": "productform-dialog-cancel"
       }, {
-        children: "Cancel"
+        children: translateKeyOutsideComponents('cancel')
       })), hasPublishButton && jsx(Button, Object.assign({
         variant: "primary",
         onClick: onPublish,
@@ -2709,7 +3199,7 @@ const getProductFormLifecycleButtons = ({
         "data-testid": "productform-dialog-publish",
         disabled: _areActionsDisabled
       }, {
-        children: "Publish"
+        children: translateKeyOutsideComponents('publish')
       }))]
     })), jsx(Box, Object.assign({
       display: {
@@ -2779,46 +3269,54 @@ const createAirmetPostParameter = (airmetToPost, newStatus, previousUuid) => {
 const getConfirmationDialogTitle = (action, productType) => {
   const product = productType.toUpperCase();
   if (action === 'CLOSED') {
-    return `Close ${product}`;
+    return `${translateKeyOutsideComponents('close')} ${product}`;
   }
   if (action === 'DISCARDED') {
-    return `Discard ${product}`;
+    return `${translateKeyOutsideComponents('discard-non-capitalized')} ${product}`;
   }
   if (action === 'PUBLISHED') {
-    return 'Publish';
+    return translateKeyOutsideComponents('publish');
   }
-  return `Cancel ${product}`;
+  return `${translateKeyOutsideComponents('cancel')} ${product}`;
 };
 const getConfirmationDialogContent = (action, productType) => {
   const product = productType.toUpperCase();
   if (action === 'DISCARDED') {
-    return `Are you sure you would like to discard this ${product}? Its properties will be lost`;
+    return translateKeyOutsideComponents('are-you-sure-you-want-to-discard', {
+      product
+    });
   }
   if (action === 'CLOSED') {
-    return 'Do you want to save any changes made?';
+    return translateKeyOutsideComponents('save-changes-made');
   }
   if (action === 'PUBLISHED') {
-    return `Are you sure you want to publish this ${product}?`;
+    return translateKeyOutsideComponents('publish-this-product', {
+      product
+    });
   }
-  return `Are you sure you want to cancel this ${product}?`;
+  return translateKeyOutsideComponents('cancel-this-product', {
+    product
+  });
 };
 const getConfirmationDialogButtonLabel = (action, productType) => {
   const product = productType.toUpperCase();
   switch (action) {
     case 'DISCARDED':
-      return `Discard ${product}`;
+      return `${translateKeyOutsideComponents('discard-product', {
+        product
+      })}`;
     case 'PUBLISHED':
-      return 'Publish';
+      return translateKeyOutsideComponents('publish');
     case 'CANCELLED':
-      return 'Cancel';
+      return translateKeyOutsideComponents('cancel');
     default:
-      return 'Save and close';
+      return translateKeyOutsideComponents('save-and-close');
   }
 };
 const getConfirmationDialogCancelLabel = action => {
   switch (action) {
     case 'CLOSED':
-      return 'Discard and close';
+      return translateKeyOutsideComponents('discard-and-close');
     default:
       return undefined;
   }
@@ -2830,7 +3328,7 @@ const getProductIssueDate = (initialProduct, initialCancelProduct) => {
   if (initialCancelProduct !== null && initialCancelProduct.issueDate) {
     return `${dateUtils.dateToString(dateUtils.utc(initialCancelProduct.issueDate), dateUtils.DATE_FORMAT_DATEPICKER)} UTC`;
   }
-  return '(Not published)';
+  return translateKeyOutsideComponents('not-published');
 };
 // Provide a cross section of the units from the config and the units as allowed by the type definition
 // Units from the config which are not in the type definition should be ignored
@@ -2867,7 +3365,7 @@ const getFir = (productConfig, firName) => {
 const isFir = geojson => {
   return geojson && geojson.features && geojson.features.length > 0 && geojson.features[0].properties['selectionType'] === 'fir';
 };
-const getFieldLabel = (title, isDisabled, action = 'Select') => isDisabled ? title : `${action} ${title.toLowerCase()}`;
+const getFieldLabel = (title, isDisabled, action = translateKeyOutsideComponents('select')) => isDisabled ? title : `${action} ${title.toLowerCase()}`;
 const getBaseLayers = productConfig => {
   var _a, _b;
   return ((_b = (_a = productConfig.mapPreset) === null || _a === void 0 ? void 0 : _a.layers) === null || _b === void 0 ? void 0 : _b.filter(layer => layer.layerType === LayerType.baseLayer || layer.layerType === LayerType.overLayer)) || [];
@@ -2904,24 +3402,32 @@ const firSelectionType = 'fir';
 const getDrawTools = (type, firShape) => {
   const defaultStyleProperties = type === StartOrEndDrawing.start ? featurePropsStart : featurePropsEnd;
   return [Object.assign(Object.assign({}, defaultPoint), {
-    title: `Drop a point as ${type} position`,
+    title: translateKeyOutsideComponents('drop-a-point-as', {
+      type
+    }),
     shape: addGeoJSONProperties(defaultPoint.shape, defaultStyleProperties)
   }), Object.assign(Object.assign({}, defaultBox), {
-    title: `Draw a box as ${type} position`,
+    title: translateKeyOutsideComponents('draw-a-box-as', {
+      type
+    }),
     shape: addGeoJSONProperties(defaultBox.shape, defaultStyleProperties)
   }), Object.assign(Object.assign({}, defaultPolygon), {
-    title: `Draw a shape as ${type} position`,
+    title: translateKeyOutsideComponents('draw-a-shape-as', {
+      type
+    }),
     shape: addGeoJSONProperties(defaultPolygon.shape, defaultStyleProperties)
   }), {
     drawModeId: 'drawtools-fir',
-    title: `Set FIR as ${type} position`,
+    title: translateKeyOutsideComponents('set-a-fir-as', {
+      type
+    }),
     isSelectable: false,
     value: DRAWMODE.POLYGON,
     // add selectionType here to use later for `onUpdateStartgeoJSON` in Sigmet/Airmet-Form when updating form values directly
     shape: addSelectionTypeToGeoJSON(addGeoJSONProperties(firShape, Object.assign({}, defaultStyleProperties)), firSelectionType),
     selectionType: firSelectionType
   }, Object.assign(Object.assign({}, defaultDelete), {
-    title: 'Remove geometry'
+    title: translateKeyOutsideComponents('remove-geometry')
   })];
 };
 const updateDrawToolsWithFir = (drawTools, newFirShape) => {
@@ -3064,10 +3570,16 @@ $$9({ global: true, forced: parseInt !== $parseInt }, {
 const DEFAULT_ROUNDING_LEVELS_FL = 5;
 const DEFAULT_ROUNDING_LEVELS_FT = 500;
 const DEFAULT_ROUNDING_LEVELS_M = 1;
-const getLevelInvalidStepsForFLUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_FL) => `Levels must be rounded to the nearest ${value}`;
-const getLevelInvalidStepsForFTUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_FT) => `Levels must be rounded to the nearest ${value}ft`;
-const getLevelInvalidStepsForMUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_M) => `Levels must be rounded to the nearest ${value}m`;
-const invalidUnitMessage$1 = 'Level unit not defined';
+const getLevelInvalidStepsForFLUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_FL) => translateKeyOutsideComponents('levels-get-level-invalid-steps-for-fl-unit-message', {
+  value
+});
+const getLevelInvalidStepsForFTUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_FT) => translateKeyOutsideComponents('levels-get-level-invalid-steps-for-ft-unit-message', {
+  value
+});
+const getLevelInvalidStepsForMUnitMessage = (value = DEFAULT_ROUNDING_LEVELS_M) => translateKeyOutsideComponents('levels-get-level-invalid-steps-for-m-unit-message', {
+  value
+});
+const invalidUnitMessage$1 = translateKeyOutsideComponents('levels-invalid-unit-message');
 const validateLevels = (value, unit, productConfig, selectedFIR) => {
   if (isEmpty(value)) {
     return true;
@@ -3092,7 +3604,7 @@ const validateLevels = (value, unit, productConfig, selectedFIR) => {
   }
   return invalidUnitMessage$1;
 };
-const invalidLevelUnitCombinationMessage = 'Invalid unit combination';
+const invalidLevelUnitCombinationMessage = translateKeyOutsideComponents('levels-invalid-level-unit-combination-message');
 const validateLevelUnitCombinations = (levelUnit, lowerLevelUnit) => {
   // If different units and lower level not SFC, only FL is allowed as upper level
   if (lowerLevelUnit !== 'SFC' && levelUnit !== lowerLevelUnit && LevelUnits[levelUnit] !== LevelUnits.FL) {
@@ -3106,6 +3618,9 @@ const Levels = ({
   onChange: _onChange = () => {},
   productConfig
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     watch,
     setValue,
@@ -3140,7 +3655,7 @@ const Levels = ({
     }
   }, [getValues, isRadioactiveCloud, levelInfoMode, radioactiveCloudLevel, setValue, trigger, unregister]);
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Levels",
+    title: t('levels'),
     sx: styles$2.containerItem
   }, {
     children: jsx(Grid, Object.assign({
@@ -3166,7 +3681,7 @@ const Levels = ({
       }, {
         children: [jsx(RadioButtonAndLabel, {
           value: "AT",
-          label: "At",
+          label: t('at'),
           checked: levelInfoMode === 'AT' || levelInfoMode === 'TOPS',
           "data-testid": "levels-AT",
           disabled: fieldsDisabled
@@ -3195,7 +3710,7 @@ const Levels = ({
                 disabled: isDisabled
               }),
               "data-testid": "levels-TOPS",
-              label: "Tops"
+              label: t('levels-tops-label')
             })
           })), jsx(Grid, Object.assign({
             item: true,
@@ -3204,7 +3719,7 @@ const Levels = ({
           }, {
             children: jsx(ReactHookFormSelect, Object.assign({
               name: "level.unit",
-              label: "Unit",
+              label: t('unit-label'),
               rules: {
                 validate: {
                   isRequired
@@ -3234,17 +3749,23 @@ const Levels = ({
             children: jsx(ReactHookFormNumberField, {
               name: "level.value",
               "data-testid": "level.value",
-              label: "Level",
+              label: t('level'),
               rules: {
                 validate: {
                   isRequired,
                   isInteger,
                   max: value =>
                   // The max level depends on the unit
-                  isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The maximum level in ${LevelUnits[getValues('level.unit')]} is ${getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                  isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-maximum-level', {
+                    levelUnit: LevelUnits[getValues('level.unit')],
+                    maxLevelValue: getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                  }),
                   min: value =>
                   // The min level depends on the unit
-                  isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The minimum level in ${LevelUnits[getValues('level.unit')]} is ${getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                  isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-minimum-level', {
+                    levelUnit: LevelUnits[getValues('level.unit')],
+                    minLevelValue: getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                  }),
                   validateLevels: value =>
                   // level step depends on the unit
                   validateLevels(value, getValues('level.unit'), productConfig, getFIRValue())
@@ -3258,7 +3779,7 @@ const Levels = ({
           }))]
         })) : null, jsx(RadioButtonAndLabel, {
           value: "BETW",
-          label: "Between",
+          label: t('between'),
           checked: levelInfoMode === 'BETW' || levelInfoMode === 'BETW_SFC',
           "data-testid": "levels-BETW",
           disabled: fieldsDisabled
@@ -3280,7 +3801,7 @@ const Levels = ({
             }, {
               children: jsx(ReactHookFormSelect, Object.assign({
                 name: "level.unit",
-                label: "Unit",
+                label: t('unit-label'),
                 rules: {
                   validate: {
                     isRequired,
@@ -3313,7 +3834,7 @@ const Levels = ({
               children: jsx(ReactHookFormNumberField, {
                 value: level || '',
                 name: "level.value",
-                label: "Upper level",
+                label: t('levels-upper-level-label'),
                 sx: styles$2.levelField,
                 size: "small",
                 rules: {
@@ -3322,10 +3843,16 @@ const Levels = ({
                     isInteger,
                     max: value =>
                     // The max level depends on the unit
-                    isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The maximum level in ${LevelUnits[getValues('level.unit')]} is ${getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                    isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-maximum-level', {
+                      levelUnit: LevelUnits[getValues('level.unit')],
+                      maxLevelValue: getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                    }),
                     min: value =>
                     // The min level depends on the unit
-                    isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The minimum level in ${LevelUnits[getValues('level.unit')]} is ${getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                    isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-minimum-level', {
+                      levelUnit: LevelUnits[getValues('level.unit')],
+                      minLevelValue: getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                    }),
                     validateLevels: value =>
                     // level step depends on the unit
                     validateLevels(value, getValues('level.unit'), productConfig, getFIRValue())
@@ -3376,7 +3903,7 @@ const Levels = ({
               }, {
                 children: jsx(ReactHookFormSelect, Object.assign({
                   name: "lowerLevel.unit",
-                  label: "Unit",
+                  label: t('unit-label'),
                   rules: {
                     validate: {
                       isRequired,
@@ -3408,17 +3935,23 @@ const Levels = ({
               }, {
                 children: jsx(ReactHookFormNumberField, {
                   name: "lowerLevel.value",
-                  label: "Lower level",
+                  label: t('levels-lower-level-label'),
                   rules: {
                     validate: {
                       isRequired,
                       isInteger,
                       max: value =>
                       // The max level depends on the unit
-                      isValidMax(value, getMaxLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)) || `The maximum level in ${LevelUnits[getValues('lowerLevel.unit')]} is ${getMaxLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)}`,
+                      isValidMax(value, getMaxLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)) || t('levels-the-maximum-level', {
+                        levelUnit: LevelUnits[getValues('lowerLevel.unit')],
+                        maxLevelValue: getMaxLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)
+                      }),
                       min: value =>
                       // The min level depends on the unit
-                      isValidMin(value, getMinLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)) || `The minimum level in ${LevelUnits[getValues('lowerLevel.unit')]} is ${getMinLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)}`,
+                      isValidMin(value, getMinLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)) || t('levels-the-minimum-level', {
+                        levelUnit: LevelUnits[getValues('lowerLevel.unit')],
+                        minLevelValue: getMinLevelValue(getValues('lowerLevel.unit'), getFIRValue(), productConfig)
+                      }),
                       isLevelLower: value =>
                       // The lower level needs to be smaller than upper level
                       isLevelLower(value, getValues('lowerLevel.unit'), getValues('level.value'), getValues('level.unit')),
@@ -3436,7 +3969,7 @@ const Levels = ({
           }))]
         }) : null, jsx(RadioButtonAndLabel, {
           value: "ABV",
-          label: "Above",
+          label: t('above'),
           disabled: fieldsDisabled,
           checked: levelInfoMode === 'ABV' || levelInfoMode === 'TOPS_ABV',
           "data-testid": "levels-ABV"
@@ -3463,7 +3996,7 @@ const Levels = ({
                 },
                 disabled: isDisabled
               }),
-              label: "Tops",
+              label: t('levels-tops-label'),
               "data-testid": "levels-TOPS_ABV"
             })
           })), jsx(Grid, Object.assign({
@@ -3473,7 +4006,7 @@ const Levels = ({
           }, {
             children: jsx(ReactHookFormSelect, Object.assign({
               name: "level.unit",
-              label: "Unit",
+              label: t('unit-label'),
               rules: {
                 validate: {
                   isRequired
@@ -3502,17 +4035,23 @@ const Levels = ({
           }, {
             children: jsx(ReactHookFormNumberField, {
               name: "level.value",
-              label: "Level",
+              label: t('level'),
               rules: {
                 validate: {
                   isRequired,
                   isInteger,
                   max: value =>
                   // The max level depends on the unit
-                  isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The maximum level in ${LevelUnits[getValues('level.unit')]} is ${getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                  isValidMax(value, getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-maximum-level', {
+                    levelUnit: LevelUnits[getValues('level.unit')],
+                    maxLevelValue: getMaxLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                  }),
                   min: value =>
                   // The min level depends on the unit
-                  isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || `The minimum level in ${LevelUnits[getValues('level.unit')]} is ${getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)}`,
+                  isValidMin(value, getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)) || t('levels-the-minimum-level', {
+                    levelUnit: LevelUnits[getValues('level.unit')],
+                    minLevelValue: getMinLevelValue(getValues('level.unit'), getFIRValue(), productConfig)
+                  }),
                   validateLevels: value =>
                   // level step depends on the unit
                   validateLevels(value, getValues('level.unit'), productConfig, getFIRValue())
@@ -3534,6 +4073,9 @@ const ObservationForecast = ({
   isDisabled,
   isReadOnly
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     watch,
     trigger,
@@ -3571,12 +4113,12 @@ const ObservationForecast = ({
     }, {
       children: [(!isReadOnly || watch('isObservationOrForecast') === 'OBS') && jsx(RadioButtonAndLabel, {
         value: "OBS",
-        label: "Observed",
+        label: t('observation-label'),
         disabled: fieldsDisabled,
         "data-testid": "isObservationOrForecast-OBS"
       }), (!isReadOnly || watch('isObservationOrForecast') === 'FCST') && jsx(RadioButtonAndLabel, {
         value: "FCST",
-        label: "Forecast",
+        label: t('forecast-label'),
         disabled: fieldsDisabled,
         "data-testid": "isObservationOrForecast-FCST"
       })]
@@ -3597,16 +4139,19 @@ const ObservationForecastTime = ({
   helperText,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     watch
   } = useFormContext();
-  const label = getFieldLabel('Date and time', isReadOnly);
+  const label = getFieldLabel(t('date-and-time'), isReadOnly);
   const {
     isShortTest
   } = useShortTestHelpers();
   const fieldsDisabled = isDisabled || isShortTest();
   return !isReadOnly || watch('observationOrForecastTime') !== null ? jsx(ProductFormFieldLayout, Object.assign({
-    title: "At"
+    title: t('at')
   }, {
     children: jsx(ReactHookFormDateTime, {
       disablePast: watch('isObservationOrForecast') === 'FCST',
@@ -3616,7 +4161,7 @@ const ObservationForecastTime = ({
       rules: {
         validate: {
           isValidDate: dateUtils.isValidIsoDateString,
-          isBefore: val => watch('isObservationOrForecast') === 'OBS' && val ? dateUtils.isBefore(val, dateUtils.getNowUtc()) || 'Observation time cannot be in the future' : true,
+          isBefore: val => watch('isObservationOrForecast') === 'OBS' && val ? dateUtils.isBefore(val, dateUtils.getNowUtc()) || t('observation-forecast-error') : true,
           isBetween: val => watch('isObservationOrForecast') === 'FCST' && val ? dateUtils.isBetween(dateUtils.isoStringToDate(val), dateUtils.isoStringToDate(goZeroSeconds(watch('validDateStart'))), dateUtils.isoStringToDate(goZeroSeconds(watch('validDateEnd'))), '[]') || ForecastTimeValidation : true
         }
       },
@@ -3636,6 +4181,9 @@ const Phenomenon = ({
   isReadOnly,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     getValues,
     setValue,
@@ -3646,10 +4194,10 @@ const Phenomenon = ({
   } = useShortTestHelpers();
   const isSigmet = productType === 'sigmet';
   const phenomenaList = isSigmet ? SigmetPhenomena : AirmetPhenomena;
-  const label = getFieldLabel('Phenomenon', isReadOnly);
+  const label = getFieldLabel(t('phenomenon'), isReadOnly);
   const fieldsDisabled = isDisabled || isShortTest();
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "What"
+    title: t('phenomenon-title')
   }, {
     children: jsx(ReactHookFormSelect, Object.assign({
       name: "phenomenon",
@@ -3684,115 +4232,14 @@ const Phenomenon = ({
   }));
 };
 
-const coordinatesEmptyMessage$1 = 'A start position drawing is required';
-const noIntersectionMessage$1 = 'The start position needs to be (partly) inside the FIR';
-const exitDrawModeMessage = 'Press ESC to exit draw mode';
-const maxFeaturePointsMessage = 'Intersection of the drawn polygon with the FIR-boundary has more than 6 individual points. Check if the TAC in the preview corresponds to the intended area.';
-const multiIntersectionsMessage = 'The drawn polygon has multiple intersections with the FIR-boundary. The drawn polygon will be used for the TAC-code.';
-const StartGeometry = ({
-  isReadOnly: _isReadOnly = false,
-  activeTool,
-  tools,
-  onChangeTool,
-  geoJSON,
-  geoJSONIntersection,
-  productConfig
-}) => {
-  var _a, _b;
-  const {
-    formState: {
-      errors
-    },
-    watch,
-    getValues
-  } = useFormContext();
-  const {
-    isDraft
-  } = useDraftFormHelpers();
-  const {
-    isShortTest
-  } = useShortTestHelpers();
-  const getFIRValue = () => getValues('locationIndicatorATSR');
-  // Max points the FIR allows for a polygon
-  const maxPoints = getMaxPolygonPoints(getFIRValue(), productConfig);
-  // Intersections with FIR
-  const intersectionPointCount = countIntersectionPoints(geoJSON, geoJSONIntersection);
-  const drawnGeometry = (_a = geoJSON === null || geoJSON === void 0 ? void 0 : geoJSON.features[0]) === null || _a === void 0 ? void 0 : _a.geometry;
-  const interceptionGeometry = (_b = geoJSONIntersection === null || geoJSONIntersection === void 0 ? void 0 : geoJSONIntersection.features[0]) === null || _b === void 0 ? void 0 : _b.geometry;
-  // Total points in the user drawn polygon
-  const totalDrawnPoints = drawnGeometry && drawnGeometry.coordinates[0] ? drawnGeometry.coordinates[0].length : 0;
-  // Total points in the intersection polygon
-  const intersectingPolygonPointsTotal = interceptionGeometry && interceptionGeometry.coordinates[0] ? interceptionGeometry.coordinates[0].length : 0;
-  const maximumPointsMessage = `The start position drawing allows a maximum of ${maxPoints - 1} individual points`;
-  const moreThan6PointsMessage = `The start/end position drawing has exceeded 6 individual points. The TAC has a total of ${totalDrawnPoints} points. If possible, reduce the number of points.`;
-  const intersectionAbove6PointsMessage = `The start/end position of the intersected polygon has 
-  ${intersectingPolygonPointsTotal} points, 
-  and the intersection of the drawn polygon with the FIR-boundary has exceeded 6 individual points.
-  Check if the TAC in the preview corresponds to the intended area.`;
-  const showMaxFeaturePointsWarning = intersectionPointCount > 7 && hasMaxFeaturePoints(geoJSONIntersection, maxPoints) && !activeTool && !errors.startGeometry && !isFir(geoJSON);
-  const showMoreThan6PointsWarning = totalDrawnPoints > 7 && intersectionPointCount < 1 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
-  const showIntersectionAbove6PointsWarning = intersectingPolygonPointsTotal > 7 && intersectionPointCount > 6 && maxPoints > 7 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
-  return !_isReadOnly ? jsxs(ProductFormFieldLayout, Object.assign({
-    title: "Start position",
-    sx: styles$2.drawSection,
-    "data-testid": "startGeometry"
-  }, {
-    children: [jsx(DrawTools, {
-      activeTool: activeTool,
-      tools: tools,
-      onChangeTool: onChangeTool,
-      isDisabled: isShortTest()
-    }), activeTool && jsx(FormHelperText, Object.assign({
-      variant: "filled",
-      sx: styles$2.quitDrawModeMessage
-    }, {
-      children: exitDrawModeMessage
-    })), !!errors.startGeometry && jsx(FormHelperText, Object.assign({
-      error: true,
-      variant: "filled"
-    }, {
-      children: errors.startGeometry.message
-    })), /* non-blocking warnings */
-    showMaxFeaturePointsWarning && jsx(FormHelperText, Object.assign({
-      variant: "filled"
-    }, {
-      children: maxFeaturePointsMessage
-    })), /* non-blocking warnings */
-    showMoreThan6PointsWarning && jsx(FormHelperText, Object.assign({
-      variant: "filled"
-    }, {
-      children: moreThan6PointsMessage
-    })), /* non-blocking warnings */
-    showIntersectionAbove6PointsWarning && jsx(FormHelperText, Object.assign({
-      variant: "filled"
-    }, {
-      children: intersectionAbove6PointsMessage
-    })), hasMulitpleIntersections(geoJSONIntersection) && !activeTool && !errors.startGeometry && !isFir(geoJSON) && jsx(FormHelperText, Object.assign({
-      variant: "filled"
-    }, {
-      children: multiIntersectionsMessage
-    })), jsx(ReactHookFormHiddenInput, {
-      name: "startGeometry",
-      rules: {
-        validate: {
-          maximumOneDrawing: value => isMaximumOneDrawing(value) || 'Only one start position drawing is allowed',
-          intersectWithFIR: value => hasIntersectionWithFIR(value, watch('startGeometryIntersect')) || noIntersectionMessage$1,
-          coordinatesNotEmpty: value => isDraft() || isShortTest() ? true : isValidGeoJsonCoordinates(value) || coordinatesEmptyMessage$1,
-          hasMaxFeaturePoints: value => isFir(value) ? true : !hasMaxFeaturePoints(value, maxPoints) || maximumPointsMessage
-        }
-      }
-    }), jsx(ReactHookFormHiddenInput, {
-      name: "startGeometryIntersect"
-    })]
-  })) : null;
-};
-
 const DEFAULT_ROUNDING_MOVEMENT_KT = 5;
 const DEFAULT_ROUNDING_MOVEMENT_KMH = 10;
-const getMovementStepValKTMessage = (value = DEFAULT_ROUNDING_MOVEMENT_KT) => `Speed should be rounded to the nearest ${value}kt`;
-const getMovementStepValKMHMessage = (value = DEFAULT_ROUNDING_MOVEMENT_KMH) => `Speed should be rounded to the nearest ${value}kmh`;
-const coordinatesEmptyMessage = 'An end position drawing is required when selecting End position';
-const noIntersectionMessage = 'The end position needs to be (partly) inside the FIR';
+const getMovementStepValKTMessage = (value = DEFAULT_ROUNDING_MOVEMENT_KT) => translateKeyOutsideComponents('progress-get-movement-step-valktmessage', {
+  value
+});
+const getMovementStepValKMHMessage = (value = DEFAULT_ROUNDING_MOVEMENT_KMH) => translateKeyOutsideComponents('progress-get-movement-step-valkmhmessage', {
+  value
+});
 const validateMovementSteps = (value, unit, productConfig, selectedFIR) => {
   if (isEmpty(value)) {
     return true;
@@ -3811,7 +4258,7 @@ const validateMovementSteps = (value, unit, productConfig, selectedFIR) => {
   if (MovementUnit[unit] === MovementUnit.KMH) {
     return intLevel % movement_rounding_kmh === 0 || getMovementStepValKMHMessage(movement_rounding_kmh);
   }
-  return 'Invalid unit';
+  return translateKeyOutsideComponents('invalid-unit');
 };
 const Progress = ({
   productType,
@@ -3826,6 +4273,9 @@ const Progress = ({
   geoJSONIntersection
 }) => {
   var _a, _b;
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     watch,
     getValues,
@@ -3873,17 +4323,11 @@ const Progress = ({
   const totalDrawnPoints = drawnGeometry && drawnGeometry.coordinates[0] ? drawnGeometry.coordinates[0].length : 0;
   // Total points in the intersection polygon
   const intersectingPolygonPointsTotal = interceptionGeometry && interceptionGeometry.coordinates[0] ? interceptionGeometry.coordinates[0].length : 0;
-  const maximumPointsMessage = `The end position drawing allows a maximum of ${maxPoints - 1} individual points`;
-  const moreThan6PointsMessage = `The start/end position drawing has exceeded 6 individual points. The TAC has a total of ${totalDrawnPoints} points. If possible, reduce the number of points.`;
-  const intersectionAbove6PointsMessage = `The start/end position of the intersected polygon has 
-  ${intersectingPolygonPointsTotal} points, 
-  and the intersection of the drawn polygon with the FIR-boundary has exceeded 6 individual points.
-  Check if the TAC in the preview corresponds to the intended area.`;
   const showMaxFeaturePointsWarning = intersectionPointCount > 7 && hasMaxFeaturePoints(geoJSONIntersection, maxPoints) && !activeTool && !errors.startGeometry && !isFir(geoJSON);
   const showMoreThan6PointsWarning = totalDrawnPoints > 7 && intersectionPointCount < 1 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
   const showIntersectionAbove6PointsWarning = intersectingPolygonPointsTotal > 7 && intersectionPointCount > 6 && maxPoints > 7 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Progress",
+    title: t('progress'),
     sx: styles$2.containerItem
   }, {
     children: jsxs(Grid, Object.assign({
@@ -3908,23 +4352,23 @@ const Progress = ({
       }, {
         children: [isVolcanicCloud && jsx(RadioButtonAndLabel, {
           value: "NO_VA_EXP",
-          label: "No volcanic ash expected",
+          label: t('progress-radio-button-label-no-va-exp'),
           disabled: fieldsDisabled,
           "data-testid": "movementType-NO_VA_EXP"
         }), jsxs(Fragment, {
           children: [jsx(RadioButtonAndLabel, {
             value: "STATIONARY",
-            label: "Stationary",
+            label: t('progress-radio-button-label-stationary'),
             disabled: fieldsDisabled,
             "data-testid": "movementType-STATIONARY"
           }), jsx(RadioButtonAndLabel, {
             value: "MOVEMENT",
-            label: "Movement",
+            label: t('progress-radio-button-label-movement'),
             disabled: fieldsDisabled,
             "data-testid": "movementType-MOVEMENT"
           }), isSigmet && isShortTestOrRdoact && jsx(RadioButtonAndLabel, {
             value: "FORECAST_POSITION",
-            label: "End position",
+            label: t('progress-radio-button-label-end-potision'),
             disabled: fieldsDisabled,
             "data-testid": "movementType-FORECAST_POSITION"
           })]
@@ -3935,7 +4379,7 @@ const Progress = ({
           }, {
             children: jsx(ReactHookFormSelect, Object.assign({
               name: "movementDirection",
-              label: "Set direction",
+              label: t('progress-movement-direction-label'),
               rules: {
                 validate: {
                   isRequired
@@ -3969,7 +4413,7 @@ const Progress = ({
             }, {
               children: jsx(ReactHookFormSelect, Object.assign({
                 name: "movementUnit",
-                label: "Unit",
+                label: t('progress-movement-unit-label'),
                 rules: {
                   validate: {
                     isRequired
@@ -3999,17 +4443,23 @@ const Progress = ({
             }, {
               children: jsx(ReactHookFormNumberField, {
                 name: "movementSpeed",
-                label: "Step speed",
+                label: t('progress-movement-speed-label'),
                 rules: {
                   validate: {
                     isRequired,
                     isInteger,
                     min: value =>
                     // The max level depends on the unit
-                    isValidMin(value, getMinMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)) || `The minimum level in ${MovementUnit[getValues('movementUnit')]} is ${getMinMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)}`,
+                    isValidMin(value, getMinMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)) || t('progress-the-minimum-level-in-movement', {
+                      movementUnitType: MovementUnit[getValues('movementUnit')],
+                      movementUnit: getMinMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)
+                    }),
                     max: value =>
                     // The max level depends on the unit
-                    isValidMax(value, getMaxMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)) || `The maximum level in ${MovementUnit[getValues('movementUnit')]} is ${getMaxMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)}`,
+                    isValidMax(value, getMaxMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)) || t('progress-the-maxium-level-in-movement', {
+                      movementUnitType: MovementUnit[getValues('movementUnit')],
+                      movementUnit: getMaxMovementSpeedValue(getValues('movementUnit'), getFIRValue(), productConfig)
+                    }),
                     validateMovementSteps: value =>
                     // movement step depends on the unit
                     validateMovementSteps(value, getValues('movementUnit'), productConfig, getFIRValue())
@@ -4025,7 +4475,7 @@ const Progress = ({
           }))]
         }), isSigmet && !isShortTestOrRdoact && jsx(RadioButtonAndLabel, {
           value: "FORECAST_POSITION",
-          label: "End position",
+          label: t('progress-radio-button-label-end-potision'),
           disabled: _isDisabled,
           "data-testid": "movementType-FORECAST_POSITION"
         })]
@@ -4045,7 +4495,7 @@ const Progress = ({
             variant: "filled",
             sx: styles$2.quitDrawModeMessage
           }, {
-            children: exitDrawModeMessage
+            children: t('geometry-exit-draw-mode-message')
           })), !!errors.endGeometry && jsx(FormHelperText, Object.assign({
             error: true,
             variant: "filled"
@@ -4055,30 +4505,36 @@ const Progress = ({
           showMaxFeaturePointsWarning && jsx(FormHelperText, Object.assign({
             variant: "filled"
           }, {
-            children: maxFeaturePointsMessage
+            children: t('geometry-max-feature-points-message')
           })), /* non-blocking warnings */
           showMoreThan6PointsWarning && jsx(FormHelperText, Object.assign({
             variant: "filled"
           }, {
-            children: moreThan6PointsMessage
+            children: t('progress-more-than-6-points-message', {
+              totalDrawnPoints
+            })
           })), /* non-blocking warnings */
           showIntersectionAbove6PointsWarning && jsx(FormHelperText, Object.assign({
             variant: "filled"
           }, {
-            children: intersectionAbove6PointsMessage
+            children: t('progress-intersection-above-6-points-message', {
+              intersectingPolygonPointsTotal
+            })
           })), hasMulitpleIntersections(geoJSONIntersection) && !activeTool && !errors.endGeometry && !isFir(geoJSON) && jsx(FormHelperText, Object.assign({
             variant: "filled"
           }, {
-            children: multiIntersectionsMessage
+            children: t('geometry-multi-intersections-message')
           }))]
         }), jsx(ReactHookFormHiddenInput, {
           name: "endGeometry",
           rules: {
             validate: {
-              maximumOneDrawing: value => isMaximumOneDrawing(value) || 'Only one end position drawing is allowed',
-              coordinatesNotEmpty: value => getValues('movementType') === 'FORECAST_POSITION' && !isDraft() ? isValidGeoJsonCoordinates(value) || coordinatesEmptyMessage : true,
-              intersectWithFIR: value => hasIntersectionWithFIR(value, getValues('endGeometryIntersect')) || noIntersectionMessage,
-              hasMaxFeaturePoints: value => isFir(value) ? true : !hasMaxFeaturePoints(value, maxPoints) || maximumPointsMessage
+              maximumOneDrawing: value => isMaximumOneDrawing(value) || t('progress-only-one-position-drawing'),
+              coordinatesNotEmpty: value => getValues('movementType') === 'FORECAST_POSITION' && !isDraft() ? isValidGeoJsonCoordinates(value) || t('progress-coordinate-empty-message') : true,
+              intersectWithFIR: value => hasIntersectionWithFIR(value, getValues('endGeometryIntersect')) || t('progress-no-intersection-message'),
+              hasMaxFeaturePoints: value => isFir(value) ? true : !hasMaxFeaturePoints(value, maxPoints) || t('progress-maximumPointsMessage', {
+                maxPoints: maxPoints - 1
+              })
             }
           }
         }), jsx(ReactHookFormHiddenInput, {
@@ -4111,6 +4567,9 @@ const SelectFIR = ({
   isReadOnly,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     setValue,
     trigger,
@@ -4143,11 +4602,11 @@ const SelectFIR = ({
     _onChange(changeEvent);
   };
   return jsxs(ProductFormFieldLayout, Object.assign({
-    title: "Where"
+    title: t('select-fir-title')
   }, {
     children: [jsx(ReactHookFormSelect, Object.assign({
       name: "locationIndicatorATSR",
-      label: isReadOnly ? 'FIR' : 'Select FIR',
+      label: isReadOnly ? 'FIR' : t('select-fir-label'),
       rules: {
         validate: {
           isRequired
@@ -4184,23 +4643,127 @@ const SelectFIR = ({
   }));
 };
 
+const StartGeometry = ({
+  isReadOnly: _isReadOnly = false,
+  activeTool,
+  tools,
+  onChangeTool,
+  geoJSON,
+  geoJSONIntersection,
+  productConfig
+}) => {
+  var _a, _b;
+  const {
+    t
+  } = useSigmetAirmetTranslation();
+  const {
+    formState: {
+      errors
+    },
+    watch,
+    getValues
+  } = useFormContext();
+  const {
+    isDraft
+  } = useDraftFormHelpers();
+  const {
+    isShortTest
+  } = useShortTestHelpers();
+  const getFIRValue = () => getValues('locationIndicatorATSR');
+  // Max points the FIR allows for a polygon
+  const maxPoints = getMaxPolygonPoints(getFIRValue(), productConfig);
+  // Intersections with FIR
+  const intersectionPointCount = countIntersectionPoints(geoJSON, geoJSONIntersection);
+  const drawnGeometry = (_a = geoJSON === null || geoJSON === void 0 ? void 0 : geoJSON.features[0]) === null || _a === void 0 ? void 0 : _a.geometry;
+  const interceptionGeometry = (_b = geoJSONIntersection === null || geoJSONIntersection === void 0 ? void 0 : geoJSONIntersection.features[0]) === null || _b === void 0 ? void 0 : _b.geometry;
+  // Total points in the user drawn polygon
+  const totalDrawnPoints = drawnGeometry && drawnGeometry.coordinates[0] ? drawnGeometry.coordinates[0].length : 0;
+  // Total points in the intersection polygon
+  const intersectingPolygonPointsTotal = interceptionGeometry && interceptionGeometry.coordinates[0] ? interceptionGeometry.coordinates[0].length : 0;
+  const showMaxFeaturePointsWarning = intersectionPointCount > 7 && hasMaxFeaturePoints(geoJSONIntersection, maxPoints) && !activeTool && !errors.startGeometry && !isFir(geoJSON);
+  const showMoreThan6PointsWarning = totalDrawnPoints > 7 && intersectionPointCount < 1 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
+  const showIntersectionAbove6PointsWarning = intersectingPolygonPointsTotal > 7 && intersectionPointCount > 6 && maxPoints > 7 && !activeTool && !errors.startGeometry && !isFir(geoJSON);
+  return !_isReadOnly ? jsxs(ProductFormFieldLayout, Object.assign({
+    title: t('start-position'),
+    sx: styles$2.drawSection,
+    "data-testid": "startGeometry"
+  }, {
+    children: [jsx(DrawTools, {
+      activeTool: activeTool,
+      tools: tools,
+      onChangeTool: onChangeTool,
+      isDisabled: isShortTest()
+    }), activeTool && jsx(FormHelperText, Object.assign({
+      variant: "filled",
+      sx: styles$2.quitDrawModeMessage
+    }, {
+      children: t('geometry-exit-draw-mode-message')
+    })), !!errors.startGeometry && jsx(FormHelperText, Object.assign({
+      error: true,
+      variant: "filled"
+    }, {
+      children: errors.startGeometry.message
+    })), /* non-blocking warnings */
+    showMaxFeaturePointsWarning && jsx(FormHelperText, Object.assign({
+      variant: "filled"
+    }, {
+      children: t('geometry-max-feature-points-message')
+    })), /* non-blocking warnings */
+    showMoreThan6PointsWarning && jsx(FormHelperText, Object.assign({
+      variant: "filled"
+    }, {
+      children: t('geometry-more-than-6-points-message', {
+        totalDrawnPoints
+      })
+    })), /* non-blocking warnings */
+    showIntersectionAbove6PointsWarning && jsx(FormHelperText, Object.assign({
+      variant: "filled"
+    }, {
+      children: t('geometry-intersection-above-6-points-message', {
+        intersectingPolygonPointsTotal
+      })
+    })), hasMulitpleIntersections(geoJSONIntersection) && !activeTool && !errors.startGeometry && !isFir(geoJSON) && jsx(FormHelperText, Object.assign({
+      variant: "filled"
+    }, {
+      children: t('geometry-multi-intersections-message')
+    })), jsx(ReactHookFormHiddenInput, {
+      name: "startGeometry",
+      rules: {
+        validate: {
+          maximumOneDrawing: value => isMaximumOneDrawing(value) || t('geometry-only-one-start-position-drawing'),
+          intersectWithFIR: value => hasIntersectionWithFIR(value, watch('startGeometryIntersect')) || t('geometry-no-intersection-message'),
+          coordinatesNotEmpty: value => isDraft() || isShortTest() ? true : isValidGeoJsonCoordinates(value) || t('geometry-coodinates-empty-message'),
+          hasMaxFeaturePoints: value => isFir(value) ? true : !hasMaxFeaturePoints(value, maxPoints) || t('geometry-maximum-points-message', {
+            maxPoints: maxPoints - 1
+          })
+        }
+      }
+    }), jsx(ReactHookFormHiddenInput, {
+      name: "startGeometryIntersect"
+    })]
+  })) : null;
+};
+
 const Type = ({
   productType,
   isReadOnly,
   isDisabled,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     getValues,
     trigger
   } = useFormContext();
-  const label = getFieldLabel('Type', isReadOnly);
+  const label = getFieldLabel(t('type-title'), isReadOnly);
   const {
     onTypeChange
   } = useShortTestHelpers();
   const messageType = productType === 'airmet' ? AirmetType : SigmetType;
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Type"
+    title: t('type-title')
   }, {
     children: jsx(ReactHookFormSelect, Object.assign({
       name: "type",
@@ -4226,8 +4789,9 @@ const Type = ({
   }));
 };
 
-const VALID_FROM_ERROR_BEFORE_CURRENT = 'Valid from time cannot be before current time';
-const getValidFromXHoursBeforeMessage = hours => `Valid from time can be no more than ${hours} hours after current time`;
+const getValidFromXHoursBeforeMessage = hours => translateKeyOutsideComponents('valid-from-time-error', {
+  hours
+});
 const getDefaultValidFromValue = productConfig => {
   const validFromDelayTimeMinutes = getValidFromDelayTimeMinutesFromConfig(productConfig);
   return dateUtils.dateToString(dateUtils.add(dateUtils.utc(), {
@@ -4240,6 +4804,9 @@ const ValidFrom = ({
   isReadOnly,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     getValues,
     trigger
@@ -4247,9 +4814,9 @@ const ValidFrom = ({
   const {
     isRequired
   } = useDraftFormHelpers();
-  const label = getFieldLabel('Date and time', isReadOnly);
+  const label = getFieldLabel(t('date-and-time'), isReadOnly);
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Valid from"
+    title: t('valid-from')
   }, {
     children: jsx(ReactHookFormDateTime, {
       disablePast: true,
@@ -4261,7 +4828,7 @@ const ValidFrom = ({
           isRequired,
           isValidDate: dateUtils.isValidIsoDateString,
           // The validity start can not be before the current time
-          isValueBeforeCurrentTime: value => isXHoursBefore(value, dateUtils.getCurrentTimeAsString(), 0) || VALID_FROM_ERROR_BEFORE_CURRENT,
+          isValueBeforeCurrentTime: value => isXHoursBefore(value, dateUtils.getCurrentTimeAsString(), 0) || t('valid-from-before-current-error'),
           // The current time can be no more than 4 hours before the validity start (12 for VA/TC SIGMET)
           isCurrentTimeXHoursBeforeValue: value => isXHoursBefore(dateUtils.getCurrentTimeAsString(), value, getHoursBeforeValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig)) || getValidFromXHoursBeforeMessage(getHoursBeforeValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig))
         }
@@ -4291,6 +4858,9 @@ const ValidUntil = ({
   isReadOnly,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     getValues,
     trigger
@@ -4298,9 +4868,10 @@ const ValidUntil = ({
   const {
     isRequired
   } = useDraftFormHelpers();
-  const label = getFieldLabel('Date and time', isReadOnly);
+  const dateAndTime = t('date-and-time');
+  const label = getFieldLabel(dateAndTime, isReadOnly);
   return jsx(ProductFormFieldLayout, Object.assign({
-    title: "Valid until"
+    title: t('valid-until')
   }, {
     children: jsx(ReactHookFormDateTime, {
       disablePast: true,
@@ -4312,9 +4883,11 @@ const ValidUntil = ({
           isRequired,
           isValidDate: dateUtils.isValidIsoDateString,
           // Validity end has to be after validity start
-          isAfter: value => value ? dateUtils.isAfter(value, getValues('validDateStart')) || 'Valid until time has to be after Valid from time' : true,
+          isAfter: value => value ? dateUtils.isAfter(value, getValues('validDateStart')) || t('valid-until-time') : true,
           // Validity end can be no more than 4 hours after validity start (6 for VA/TC SIGMET)
-          isXHoursAfter: value => isXHoursAfter(value, getValues('validDateStart'), getMaxHoursOfValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig)) || `Valid until time can be no more than ${getMaxHoursOfValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig)} hours after Valid from time`
+          isXHoursAfter: value => isXHoursAfter(value, getValues('validDateStart'), getMaxHoursOfValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig)) || t('valid-until-time-error', {
+            hours: getMaxHoursOfValidity(getValues('phenomenon'), getValues('locationIndicatorATSR'), productConfig)
+          })
         }
       },
       disabled: isDisabled,
@@ -4333,6 +4906,9 @@ const VolcanicFields = ({
   isReadOnly,
   helperText
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     watch,
     trigger,
@@ -4361,7 +4937,7 @@ const VolcanicFields = ({
       }, {
         children: jsx(ReactHookFormTextField, {
           name: "vaSigmetVolcanoName",
-          label: "Volcano name",
+          label: t('volcano-name'),
           rules: {
             required: false
           },
@@ -4378,7 +4954,7 @@ const VolcanicFields = ({
         children: jsx(ReactHookFormNumberField, {
           name: "vaSigmetVolcanoCoordinates.latitude",
           "data-testid": "vaSigmetVolcanoCoordinates.latitude",
-          label: "Latitude",
+          label: t('latitude'),
           inputMode: "decimal",
           rules: {
             required: true,
@@ -4400,7 +4976,7 @@ const VolcanicFields = ({
         children: jsx(ReactHookFormNumberField, {
           name: "vaSigmetVolcanoCoordinates.longitude",
           "data-testid": "vaSigmetVolcanoCoordinates.longitude",
-          label: "Longitude",
+          label: t('longitude'),
           inputMode: "decimal",
           size: "small",
           sx: Object.assign({}, styles$2.latitude),
@@ -4422,7 +4998,9 @@ const VolcanicFields = ({
 
 const DEFAULT_ROUNDING_SURFACE_VISIBLILITY_BELOW = 50;
 const DEFAULT_ROUNDING_SURFACE_VISIBLILITY_ABOVE = 100;
-const getInvalidSurfaceVisibilityTill750StepsMessage = (value = DEFAULT_ROUNDING_SURFACE_VISIBLILITY_BELOW) => `A visibility below 750m must be rounded to the nearest ${value}m`;
+const getInvalidSurfaceVisibilityTill750StepsMessage = (value = DEFAULT_ROUNDING_SURFACE_VISIBLILITY_BELOW) => translateKeyOutsideComponents('invalid-surface-visibility-till-750-steps-message', {
+  value
+});
 const getInvalidSurfaceVisibilityFrom750StepsMessage = (value = DEFAULT_ROUNDING_SURFACE_VISIBLILITY_ABOVE) => `A visibility above 750m must be rounded to the nearest ${value}m`;
 const validateSurfaceVisibility = (value, productConfig, selectedFIR) => {
   if (isEmpty(value)) {
@@ -4447,6 +5025,9 @@ const SurfaceVisibility = ({
   productConfig,
   onChange: _onChange = () => {}
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     isRequired
   } = useDraftFormHelpers();
@@ -4454,8 +5035,8 @@ const SurfaceVisibility = ({
     getValues
   } = useFormContext();
   const getFIRValue = () => getValues('locationIndicatorATSR');
-  const visibilityLabel = getFieldLabel('Visibility', isReadOnly);
-  const visibilityCauseLabel = getFieldLabel('Cause', isReadOnly);
+  const visibilityLabel = getFieldLabel(t('surface-visibility'), isReadOnly);
+  const visibilityCauseLabel = getFieldLabel(t('surface-visibility-cause'), isReadOnly);
   return jsxs(Grid, Object.assign({
     item: true,
     container: true,
@@ -4481,16 +5062,20 @@ const SurfaceVisibility = ({
           name: "visibilityValue",
           "data-testid": "surfaceVisibility-visibilityValue",
           label: visibilityLabel,
-          helperText: "Value in meters",
+          helperText: t('surface-visibility-helper-text'),
           rules: {
             validate: {
               isRequired,
               min: value =>
               // The min level depends on the unit
-              isValidMin(value, getMinVisibilityValue(getFIRValue(), productConfig)) || `The minimum visibility in meters is ${getMinVisibilityValue(getFIRValue(), productConfig)}`,
+              isValidMin(value, getMinVisibilityValue(getFIRValue(), productConfig)) || t('surface-visibility-minimum-visibility', {
+                minimumVisibility: getMinVisibilityValue(getFIRValue(), productConfig)
+              }),
               max: value =>
               // The max level depends on the unit
-              isValidMax(value, getMaxVisibilityValue(getFIRValue(), productConfig)) || `The maximum visibility in meters is ${getMaxVisibilityValue(getFIRValue(), productConfig)}`,
+              isValidMax(value, getMaxVisibilityValue(getFIRValue(), productConfig)) || t('surface-visibility-maximum-visibility', {
+                maximumVisibility: getMaxVisibilityValue(getFIRValue(), productConfig)
+              }),
               validateSurfaceVisibility: value => validateSurfaceVisibility(value, productConfig, getFIRValue())
             }
           },
@@ -4531,7 +5116,9 @@ const SurfaceVisibility = ({
 };
 
 const DEFAULT_ROUNDING_SURFACE_WIND_DIRECTION = 10;
-const invalidSurfaceWindDirectionStepsMessage = (value = DEFAULT_ROUNDING_SURFACE_WIND_DIRECTION) => `Direction must be rounded to the nearest ${value} deg.`;
+const invalidSurfaceWindDirectionStepsMessage = (value = DEFAULT_ROUNDING_SURFACE_WIND_DIRECTION) => translateKeyOutsideComponents('invalid-surface-wind-direction-message', {
+  value
+});
 const validateSurfaceWindDirection = (value, productConfig, selectedFIR) => {
   if (isEmpty(value)) {
     return true;
@@ -4550,6 +5137,9 @@ const SurfaceWind = ({
   onChange: _onChange = () => null,
   productConfig
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     trigger,
     getValues
@@ -4560,8 +5150,8 @@ const SurfaceWind = ({
   const getFIRValue = () => getValues('locationIndicatorATSR');
   // Get allowed speed units based on selected FIR - if no FIR selected, allow all units
   const allowedWindUnitsForFir = getAllowedUnits(getFIRValue(), productConfig, 'surfacewind_unit', WindUnit);
-  const windLabel = getFieldLabel('Wind direction', isReadOnly, 'Set');
-  const speedLabel = getFieldLabel('Speed', isReadOnly, 'Set');
+  const windLabel = getFieldLabel(t('surface-wind-label'), isReadOnly, t('set'));
+  const speedLabel = getFieldLabel(t('surface-wind-speed-label'), isReadOnly, t('set'));
   return jsxs(Grid, Object.assign({
     item: true,
     container: true,
@@ -4586,15 +5176,15 @@ const SurfaceWind = ({
         children: jsx(ReactHookFormNumberField, {
           name: "windDirection",
           label: windLabel,
-          helperText: "Value in degrees",
+          helperText: t('surface-wind-helper-text'),
           rules: {
             min: {
               value: 10,
-              message: 'Direction should be between 10 and 360 deg.'
+              message: t('surface-wind-rule-min-max-message')
             },
             max: {
               value: 360,
-              message: 'Direction should be between 10 and 360 deg.'
+              message: t('surface-wind-rule-min-max-message')
             },
             validate: {
               isRequired,
@@ -4617,7 +5207,7 @@ const SurfaceWind = ({
         }, {
           children: jsx(ReactHookFormSelect, Object.assign({
             name: "windUnit",
-            label: "Unit",
+            label: t('unit-label'),
             rules: {
               validate: {
                 isRequired
@@ -4653,10 +5243,16 @@ const SurfaceWind = ({
                 isInteger,
                 min: value =>
                 // The min level depends on the unit
-                isValidMin(value, getMinWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)) || `The minimum wind speed in ${WindUnit[getValues('windUnit')]} is ${getMinWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)}`,
+                isValidMin(value, getMinWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)) || t('surface-wind-minimum-wind-speed', {
+                  windUnit: WindUnit[getValues('windUnit')],
+                  minWindSpeedValue: getMinWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)
+                }),
                 max: value =>
                 // The max level depends on the unit
-                isValidMax(value, getMaxWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)) || `The maximum wind speed in ${WindUnit[getValues('windUnit')]} is ${getMaxWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)}`
+                isValidMax(value, getMaxWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)) || t('surface-wind-maximum-wind-speed', {
+                  windUnit: WindUnit[getValues('windUnit')],
+                  maxWindSpeedValue: getMaxWindSpeedValue(getValues('windUnit'), getFIRValue(), productConfig)
+                })
               }
             },
             size: "small",
@@ -4715,6 +5311,9 @@ const CloudLevels = ({
   const {
     isRequired
   } = useDraftFormHelpers();
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const getFIRValue = () => getValues('locationIndicatorATSR');
   const cloudLevelInfoMode = watch('cloudLevelInfoMode');
   // Get allowed cloud level units based on selected FIR - if no FIR selected, allow all default units
@@ -4740,7 +5339,7 @@ const CloudLevels = ({
         variant: "subtitle1",
         sx: styles$2.label
       }, {
-        children: "Levels"
+        children: t('levels')
       }))
     })), jsx(Grid, Object.assign({
       item: true,
@@ -4980,7 +5579,8 @@ const CloudLevels = ({
   }));
 };
 
-const noTAC = 'Missing data: no TAC can be generated';
+// ToDo check if this can be transated here
+const noTAC = translateKeyOutsideComponents('tac-missing-data');
 const isLevelFieldsComplete = product => {
   var _a, _b, _c, _d, _e, _f;
   switch (product.phenomenon) {
@@ -5054,6 +5654,10 @@ const shouldRetrieveTAC = (product, omitChange) => {
   return false;
 };
 const useTAC = (initialProduct, getTAC, hasErrors = () => false, omitChange) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
+  const noTAC = t('tac-missing-data');
   const [TAC, setTAC] = React__default.useState(noTAC);
   const {
     isMounted
@@ -5128,6 +5732,9 @@ const IssuedAt = ({
   date,
   isReadOnly
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   return jsx(ProductFormFieldLayout, Object.assign({
     sx: {
       paddingTop: 0,
@@ -5135,7 +5742,7 @@ const IssuedAt = ({
         paddingTop: 0
       }
     },
-    title: "Issued at"
+    title: t('issued-at')
   }, {
     children: jsx(Grid, Object.assign({
       item: true,
@@ -9390,6 +9997,9 @@ const SigmetForm = ({
   productConfig: _productConfig = sigmetConfig,
   setDialogActionsDisabled
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     api
   } = useApiContext();
@@ -9625,7 +10235,7 @@ const SigmetForm = ({
           sx: styles$2.body,
           "data-testid": "vaSigmetMoveToFIR"
         }, {
-          children: ["Volcanic Cloud is moving in the direction of:", ' ', jsxs("b", {
+          children: [t('vulcanic-cloud-moving-text'), ":", ' ', jsxs("b", {
             children: [" ", watch('vaSigmetMoveToFIR')]
           })]
         }))
@@ -9954,6 +10564,9 @@ const ContentDialog = _a => {
       alertBanner = null
     } = _a,
     other = __rest(_a, ["open", "toggleDialogStatus", "title", "children", "options", "onClose", "alertBanner"]);
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const theme = useTheme();
   const handleClose = () => {
     if (onClose) {
@@ -10021,7 +10634,7 @@ const ContentDialog = _a => {
               }
             }
           }, {
-            children: "BACK"
+            children: t('back')
           }))
         })), jsx(Grid, Object.assign({
           item: true,
@@ -10221,6 +10834,9 @@ const ProductListRow = ({
   product,
   productType
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     api
   } = useApiContext();
@@ -10311,7 +10927,7 @@ const ProductListRow = ({
           item: true
         }, {
           children: [jsx(ProductListRowHeader, {
-            title: "Issue time"
+            title: t('issue-time')
           }), jsx(CustomTooltip, Object.assign({
             title: jsxs(Fragment, {
               children: [jsx(ProductListRowHeader, {
@@ -10352,7 +10968,7 @@ const ProductListRow = ({
               sx: styles.font,
               "data-testid": "issueTime"
             }, {
-              children: product.issueDate ? `${dateUtils.dateToString(dateUtils.utc(product.issueDate), dateUtils.DATE_FORMAT_NAME_OF_MONTH)} UTC` : '(Not published)'
+              children: product.issueDate ? `${dateUtils.dateToString(dateUtils.utc(product.issueDate), dateUtils.DATE_FORMAT_NAME_OF_MONTH)} UTC` : t('not-published')
             }))
           }))]
         })), jsxs(Grid, Object.assign({
@@ -10360,7 +10976,7 @@ const ProductListRow = ({
           item: true
         }, {
           children: [jsx(ProductListRowHeader, {
-            title: "Valid time"
+            title: t('valid-time')
           }), jsx(Typography, Object.assign({
             variant: "subtitle2",
             sx: styles.font,
@@ -10380,7 +10996,7 @@ const ProductListRow = ({
             variant: "flat",
             startIcon: jsx(Edit, {})
           }, {
-            children: "DRAFT"
+            children: t('draft')
           })) : getStatusTagList(product, cancelsSeqId), product.status === 'PUBLISHED' && cancelsSeqId === null && getActiveStatus(product)]
         }))]
       }))
@@ -10388,97 +11004,6 @@ const ProductListRow = ({
   }));
 };
 
-const ERROR_CONFIG = 'An error has occurred while loading the config';
-const ERROR_BACKEND = 'An error has occurred while retrieving the list, please try again';
-const ERROR_AUTH$1 = 'This feature is protected by authentication.';
-const validateConfig = (productType, productConfig) => {
-  const validatedConfig = productType === 'sigmet' ? validateSigmet(productConfig) : validateAirmet(productConfig);
-  if (validatedConfig !== true && Array.isArray(validatedConfig)) {
-    const error = {
-      name: ERROR_CONFIG,
-      message: createReadableErrorMessage(validatedConfig)
-    };
-    return error;
-  }
-  return true;
-};
-const useProductApi = (productType, productConfig) => {
-  const [state, setState] = React__default.useState({
-    isLoading: false,
-    error: undefined,
-    result: []
-  });
-  const {
-    isMounted
-  } = useIsMounted();
-  const {
-    api
-  } = useApiContext();
-  const requestList = productType === 'sigmet' ? api.getSigmetList : api.getAirmetList;
-  const {
-    isLoggedIn
-  } = useAuthenticationContext();
-  const updateState = newState => {
-    if (isMounted.current) {
-      setState(currentState => Object.assign(Object.assign({}, currentState), newState));
-    }
-  };
-  const fetchNewData = () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Check for authentication before fetching data
-    if (!isLoggedIn && Array.isArray(isLoggedIn)) {
-      const newError = {
-        name: ERROR_AUTH$1,
-        message: createReadableErrorMessage(isLoggedIn)
-      };
-      updateState(Object.assign(Object.assign({}, state), {
-        error: newError,
-        isLoading: false
-      }));
-      return;
-    }
-    // don't try to fetch when error coming from config or is loading already
-    if (((_a = state.error) === null || _a === void 0 ? void 0 : _a.name) === ERROR_CONFIG || state.isLoading) {
-      return;
-    }
-    updateState(Object.assign(Object.assign({}, state), {
-      isLoading: true,
-      error: undefined
-    }));
-    try {
-      const {
-        data
-      } = yield requestList();
-      updateState(Object.assign(Object.assign({}, state), {
-        result: data,
-        isLoading: false
-      }));
-    } catch (error) {
-      const newError = Object.assign(Object.assign({}, error), {
-        name: ERROR_BACKEND
-      });
-      updateState(Object.assign(Object.assign({}, state), {
-        error: newError,
-        isLoading: false
-      }));
-    }
-  });
-  React__default.useEffect(() => {
-    const validatedConfig = validateConfig(productType, productConfig);
-    if (validatedConfig !== true) {
-      updateState(Object.assign(Object.assign({}, state), {
-        error: validatedConfig
-      }));
-    } else {
-      fetchNewData();
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-  return Object.assign(Object.assign({}, state), {
-    fetchNewData
-  });
-};
-
 const ProductList = ({
   productType,
   productList,
@@ -10487,7 +11012,10 @@ const ProductList = ({
   onClickProductRow,
   onClickNewProduct
 }) => {
-  const shouldHideCreateNew = error && (error.name === ERROR_AUTH$1 || error.name === ERROR_CONFIG);
+  const {
+    t
+  } = useSigmetAirmetTranslation();
+  const shouldHideCreateNew = error && (error.name === t('error-auth') || error.name === t('error-config'));
   return jsxs(Grid, Object.assign({
     container: true,
     direction: "column",
@@ -10498,7 +11026,7 @@ const ProductList = ({
       item: true,
       justifyContent: "flex-end"
     }, {
-      children: !shouldHideCreateNew && jsxs(Button, Object.assign({
+      children: !shouldHideCreateNew && jsx(Button, Object.assign({
         variant: "primary",
         "data-testid": "productListCreateButton",
         onClick: onClickNewProduct,
@@ -10506,7 +11034,9 @@ const ProductList = ({
           textTransform: 'initial'
         }
       }, {
-        children: ["Create a new ", productType.toUpperCase()]
+        children: t('create-new-product', {
+          product: productType.toUpperCase()
+        })
       }))
     })), jsxs(Grid, Object.assign({
       item: true,
@@ -10563,14 +11093,17 @@ const CancelSigmetVolcanicMovements = ({
   productConfig
 }) => {
   const allFIRS = getAllFirAreas(productConfig);
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     isRequired
   } = useDraftFormHelpers();
   return jsxs(Fragment, {
-    children: [jsx(Typography, Object.assign({
+    children: [jsxs(Typography, Object.assign({
       variant: "body1"
     }, {
-      children: "Use the FIR to indicate the direction the Volcanic Ash is moving to:"
+      children: [t('vulcanic-ash-description'), ":"]
     })), jsxs(ReactHookFormRadioGroup, Object.assign({
       name: "vaSigmetMoveToFIR",
       rules: {
@@ -10579,7 +11112,7 @@ const CancelSigmetVolcanicMovements = ({
         }
       },
       row: true,
-      defaultValue: "UNKNOWN"
+      defaultValue: t('unknown').toUpperCase()
     }, {
       children: [allFIRS[sigmet.locationIndicatorATSR].adjacent_firs.map(adjacentFIR => {
         return jsx(FormControlLabel, {
@@ -10590,7 +11123,7 @@ const CancelSigmetVolcanicMovements = ({
       }), jsx(FormControlLabel, {
         value: "UNKNOWN",
         control: jsx(Radio, {}),
-        label: "Cancel VA SIGMET without VA MOV TO information"
+        label: t('vulcanic-VA-SIGMET-text')
       }, "UNKNOWN")]
     }))]
   });
@@ -10837,6 +11370,94 @@ const ProductFormDialog = ({
   });
 };
 
+const validateConfig = (productType, productConfig) => {
+  const validatedConfig = productType === 'sigmet' ? validateSigmet(productConfig) : validateAirmet(productConfig);
+  if (validatedConfig !== true && Array.isArray(validatedConfig)) {
+    const error = {
+      name: translateKeyOutsideComponents('error-config'),
+      message: createReadableErrorMessage(validatedConfig)
+    };
+    return error;
+  }
+  return true;
+};
+const useProductApi = (productType, productConfig) => {
+  const [state, setState] = React__default.useState({
+    isLoading: false,
+    error: undefined,
+    result: []
+  });
+  const {
+    isMounted
+  } = useIsMounted();
+  const {
+    api
+  } = useApiContext();
+  const requestList = productType === 'sigmet' ? api.getSigmetList : api.getAirmetList;
+  const {
+    isLoggedIn
+  } = useAuthenticationContext();
+  const updateState = newState => {
+    if (isMounted.current) {
+      setState(currentState => Object.assign(Object.assign({}, currentState), newState));
+    }
+  };
+  const fetchNewData = () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // Check for authentication before fetching data
+    if (!isLoggedIn && Array.isArray(isLoggedIn)) {
+      const newError = {
+        name: translateKeyOutsideComponents('error-auth'),
+        message: createReadableErrorMessage(isLoggedIn)
+      };
+      updateState(Object.assign(Object.assign({}, state), {
+        error: newError,
+        isLoading: false
+      }));
+      return;
+    }
+    // don't try to fetch when error coming from config or is loading already
+    if (((_a = state.error) === null || _a === void 0 ? void 0 : _a.name) === translateKeyOutsideComponents('error-config') || state.isLoading) {
+      return;
+    }
+    updateState(Object.assign(Object.assign({}, state), {
+      isLoading: true,
+      error: undefined
+    }));
+    try {
+      const {
+        data
+      } = yield requestList();
+      updateState(Object.assign(Object.assign({}, state), {
+        result: data,
+        isLoading: false
+      }));
+    } catch (error) {
+      const newError = Object.assign(Object.assign({}, error), {
+        name: translateKeyOutsideComponents('error-backend')
+      });
+      updateState(Object.assign(Object.assign({}, state), {
+        error: newError,
+        isLoading: false
+      }));
+    }
+  });
+  React__default.useEffect(() => {
+    const validatedConfig = validateConfig(productType, productConfig);
+    if (validatedConfig !== true) {
+      updateState(Object.assign(Object.assign({}, state), {
+        error: validatedConfig
+      }));
+    } else {
+      fetchNewData();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return Object.assign(Object.assign({}, state), {
+    fetchNewData
+  });
+};
+
 /**
  * Shows the list of Sigmets or Airmets and allows to create, edit and view Sigmets/Airmets.
  * Needs to be wrapped in the ApiProvider.
@@ -10909,12 +11530,13 @@ const MetInfoWrapper = ({
   }));
 };
 
-const ERROR_TITLE = 'Something went wrong with loading the configuration file';
-const ERROR_AUTH = 'This feature is protected by authentication. Please log in to proceed';
 const DownloadSigmetAirmetConfigWrapper = ({
   productType,
   productConfigKey
 }) => {
+  const {
+    t
+  } = useSigmetAirmetTranslation();
   const {
     api
   } = useApiContext();
@@ -10942,8 +11564,8 @@ const DownloadSigmetAirmetConfigWrapper = ({
   }
   if (error) {
     return jsx(AlertBanner, {
-      title: ERROR_TITLE,
-      info: !isLoggedIn ? ERROR_AUTH : error.message
+      title: t('error-title'),
+      info: !isLoggedIn ? t('error-auth-login') : error.message
     });
   }
   return jsx(MetInfoWrapper, {
@@ -14596,6 +15218,4 @@ ConnectedModuleWrapper = null) => {
   }
 };
 
-const SA_NAMESPACE = 'sigmetairmet';
-
 export { AirmetComponentsLookUp, AirmetForm, AirmetPhenomena, AirmetType, CloudLevelUnits, ContentDialog, Direction, DownloadSigmetAirmetConfigWrapper, LevelUnits, MapViewGeoJson, MetInfoWrapper, MovementUnit, ProductList, ProductListRow, ProductStatusDescription, SA_NAMESPACE, SigmetComponentsLookUp, SigmetForm, SigmetPhenomena, SigmetType, StartOrEndDrawing, VisibilityCause, WindUnit, airmetConfig, createApi$1 as createApi, createApi as createFakeApi, isInstanceOfAirmet, isInstanceOfCancelAirmet, isInstanceOfCancelSigmet, isInstanceOfCancelSigmetOrAirmet, isInstanceOfSigmet, isInstanceOfSigmetOrAirmet, sigmetAirmetTranslations as saTranslations, sigmetConfig };