@opengeoweb/taf 12.0.0 → 12.1.1

package/index.esm.js

@@ -6,19 +6,21 @@ import { useFormContext, useFieldArray, Controller } from 'react-hook-form';
 import { useDispatch } from 'react-redux';
 import { ReactSortable } from 'react-sortablejs';
 import Sortable from 'sortablejs';
-import { getConfig, useAuthenticationContext } from '@opengeoweb/authentication';
+import { getConfig, useAuthenticationContext as useAuthenticationContext$1 } from '@opengeoweb/authentication';
 import { HIDDEN_INPUT_HELPER_IS_DRAFT, getDeepProperty, useDraftFormHelpers, ReactHookFormHiddenInput, ReactHookFormProvider } from '@opengeoweb/form-fields';
-import { SHARED_NAMESPACE, dateUtils, useIsMounted, CustomIconButton, CustomTooltip, ToolContainerDraggable, Avatar, getInitials, ToggleMenu, useConfirmationDialog, usePreventBrowserClose, SwitchButton, ToolHeader, AlertBanner, getErrorMessage as getErrorMessage$1, getWarningMessage, LastUpdateTime, ErrorBoundary } from '@opengeoweb/shared';
+import { SHARED_NAMESPACE, dateUtils, getErrorMessage as getErrorMessage$1, getWarningMessage, CustomIconButton, CustomTooltip, ToolContainerDraggable, Avatar, getInitials, ToggleMenu, useConfirmationDialog, usePreventBrowserClose, SwitchButton, ToolHeader, AlertBanner, LastUpdateTime, ErrorBoundary } from '@opengeoweb/shared';
 import { snackbarActions, snackbarTypes } from '@opengeoweb/snackbar';
 import 'i18next';
 import { useTranslation } from 'react-i18next';
 import { isEqual } from 'lodash';
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { getHeaders, handleResponse, useAuthQuery, useAuthenticationContext } from '@opengeoweb/api';
 import { DragHandle as DragHandle$1, ThumbsUp, Add, Delete, Close, Clock, Cancel, Success, Edit, Export, ListItem } from '@opengeoweb/theme';
 import ReactDOM from 'react-dom';
 import { useTheme } from '@emotion/react';
-import { getHeaders, handleResponse, useAuthQuery, useApiContext, createApiInstance, createFakeApiInstance, ApiProvider } from '@opengeoweb/api';
 import LinearProgress from '@mui/material/LinearProgress';
 import Box$1 from '@mui/material/Box';
+import { http, HttpResponse, delay } from 'msw';
 
 var en = {
 	"issues-button-title": "View details",
@@ -2607,438 +2609,468 @@ var validateFourthCloud = function validateFourthCloud(firstCloudValue, secondCl
 var DATE_FORMAT_ISSUE_TIME = "ddHHmm'Z";
 var DATE_FORMAT_BASE_TIME = 'HH:mm dd MMM';
 
-var _excluded$5 = ["cavOK"],
-  _excluded2 = ["visibility"],
-  _excluded3 = ["cloud"],
-  _excluded4 = ["weather"],
-  _excluded5 = ["wind"],
-  _excluded6 = ["visibility"],
-  _excluded7 = ["IS_DRAFT"],
-  _excluded8 = ["changeGroups"],
-  _excluded9 = ["valid"],
-  _excluded10 = ["valid"];
-var emptyBaseForecast = {
-  wind: '',
-  visibility: '',
-  weather: {
-    weather1: '',
-    weather2: '',
-    weather3: ''
-  },
-  cloud: {
-    cloud1: '',
-    cloud2: '',
-    cloud3: '',
-    cloud4: ''
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2025 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2025 - Finnish Meteorological Institute (FMI)
+ * Copyright 2025 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var config = getConfig();
+var tafBaseUrl = config.GW_TAF_BASE_URL || '';
+var getTafList = function getTafList(auth) {
+  return fetch(tafBaseUrl + "/taflist", {
+    headers: getHeaders(auth)
+  }).then(handleResponse);
+};
+var postTaf = function postTaf(auth, data) {
+  return fetch(tafBaseUrl + "/taf", {
+    method: 'POST',
+    headers: getHeaders(auth),
+    body: JSON.stringify(data)
+  }).then(handleResponse);
+};
+var patchTaf = function patchTaf(auth, data) {
+  return fetch(tafBaseUrl + "/taf?force=true", {
+    method: 'PATCH',
+    headers: getHeaders(auth),
+    body: JSON.stringify(data)
+  }).then(handleResponse);
+};
+var getTAC = function getTAC(auth, data) {
+  return fetch(tafBaseUrl + "/taf2tac", {
+    method: 'POST',
+    headers: getHeaders(auth),
+    body: JSON.stringify(data)
+  }).then(handleResponse);
+};
+
+var location_indicator_mwo = "EHDB";
+var locations = {
+	EHAM: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Schiphol"
+	},
+	EHRD: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Rotterdam"
+	},
+	EHGG: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Eelde"
+	},
+	EHBK: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Maastricht"
+	},
+	EHLE: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Lelystad"
+	},
+	TNCB: {
+		validity_duration: 30,
+		activity_period: 6,
+		label: "Bonaire"
+	}
+};
+var locationOrder = [
+	"EHAM",
+	"EHRD",
+	"EHLE",
+	"EHGG",
+	"EHBK",
+	"TNCB"
+];
+var autoTAFlocations = [
+	"EHAM",
+	"EHRD",
+	"EHLE",
+	"EHGG",
+	"EHBK"
+];
+var tafConfig = {
+	location_indicator_mwo: location_indicator_mwo,
+	locations: locations,
+	locationOrder: locationOrder,
+	autoTAFlocations: autoTAFlocations
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+// TODO: should be validated
+var getTafSettings = function getTafSettings() {
+  return tafConfig;
+};
+var tafSettings = getTafSettings();
+var getLocationSetting = function getLocationSetting(location, locationSettings) {
+  if (locationSettings === void 0) {
+    locationSettings = tafSettings.locations;
   }
+  return locationSettings[location];
 };
-var MIN_NUMBER_CHANGE_GROUP = 5;
-// formatters
-var formatIssueTime = function formatIssueTime(issueDate) {
-  var issueDateAsString = dateUtils.dateToString(new Date(issueDate), DATE_FORMAT_ISSUE_TIME);
-  return issueDateAsString || 'Not issued';
+var sortTafsOnLocation = function sortTafsOnLocation(tafList, locationOrder) {
+  if (tafList === void 0) {
+    tafList = [];
+  }
+  if (locationOrder === void 0) {
+    locationOrder = tafSettings.locationOrder;
+  }
+  return [].concat(tafList).sort(function (_ref, _ref2) {
+    var tafA = _ref.taf;
+    var tafB = _ref2.taf;
+    return locationOrder.indexOf(tafA.location) < locationOrder.indexOf(tafB.location) ? -1 : 1;
+  });
 };
-function formatFormValues(row) {
-  return Object.keys(row).reduce(function (list, key) {
-    switch (key) {
-      case 'valid':
-        {
-          return Object.assign({}, list, {
-            valid: formatValidToString(list[key])
-          });
-        }
-      case 'wind':
-        {
-          return Object.assign({}, list, {
-            wind: formatWindToString(list[key])
-          });
-        }
-      case 'visibility':
-        {
-          // Assume if visibility field set - no cavOK
-          return Object.assign({}, list, {
-            visibility: formatVisibilityToString(list[key])
-          });
-        }
-      case 'cavOK':
-        {
-          // Assume if cavOK field set to true - no visibility field, otherwise return the original list containing the visibility and remove cavOK
-          list.cavOK;
-            var formData = _objectWithoutPropertiesLoose(list, _excluded$5);
-          if (list[key]) {
-            return Object.assign({}, formData, {
-              visibility: formatVisibilityToString(list[key])
-            });
-          }
-          return formData;
-        }
-      case 'cloud':
-        {
-          return Object.assign({}, list, {
-            cloud: formatCloudsToString(list[key])
-          });
-        }
-      default:
-        {
-          return list;
-        }
-    }
-  }, row);
-}
-// parsers
-function reduceRowValues(row, tafStart, tafEnd) {
-  return Object.keys(row).reduce(function (list, key) {
-    switch (key) {
-      case 'valid':
-        {
-          return Object.assign({}, list, {
-            valid: parseValidToObject(list[key], tafStart, tafEnd)
-          });
-        }
-      case 'wind':
-        {
-          return Object.assign({}, list, {
-            wind: parseWindToObject(list[key])
-          });
-        }
-      case 'visibility':
-        {
-          return Object.assign({}, list, parseVisibilityToObject(list[key]));
-        }
-      case 'weather':
-        {
-          return Object.assign({}, list, {
-            weather: parseWeatherToObject(list[key])
-          });
-        }
-      case 'cloud':
-        {
-          return Object.assign({}, list, {
-            cloud: parseCloudsToObject(list[key])
-          });
-        }
-      // Trim string field
-      case 'change':
-      case 'probability':
-        {
-          var _Object$assign;
-          return Object.assign({}, list, (_Object$assign = {}, _Object$assign[key] = String(list[key]).trim(), _Object$assign));
-        }
-      default:
-        {
-          return list;
-        }
+var sortTafsOnIssueDate = function sortTafsOnIssueDate(tafList) {
+  if (tafList === void 0) {
+    tafList = [];
+  }
+  return [].concat(tafList).sort(function (_ref3, _ref4) {
+    var tafA = _ref3.taf;
+    var tafB = _ref4.taf;
+    if (tafA.issueDate < tafB.issueDate || tafA.issueDate && !tafB.issueDate) {
+      return 1;
     }
-  }, row);
-}
-function parseFormValues(row, tafStart, tafEnd) {
-  var reducedRow = reduceRowValues(row, tafStart, tafEnd);
-  return Object.keys(reducedRow).reduce(function (list, key) {
-    switch (key) {
-      case 'cavOK':
-        {
-          // if cavOK is set - remove visibility from the list
-          if (reducedRow.cavOK) {
-            list.visibility;
-              var rest = _objectWithoutPropertiesLoose(list, _excluded2);
-            return rest;
-          }
-          return list;
-        }
-      case 'cloud':
-        {
-          // If cloud is undefined or empty, remove it from the list
-          if (!reducedRow.cloud || Object.keys(reducedRow.cloud).length === 0) {
-            list.cloud;
-              var _rest = _objectWithoutPropertiesLoose(list, _excluded3);
-            return _rest;
-          }
-          return list;
-        }
-      case 'weather':
-        {
-          // If empty, remove it from the list
-          if (!reducedRow.weather.weather1) {
-            list.weather;
-              var _rest2 = _objectWithoutPropertiesLoose(list, _excluded4);
-            return _rest2;
-          }
-          return list;
-        }
-      case 'wind':
-        {
-          // If empty, remove it from the list
-          if (!reducedRow.wind.direction && isNaN(Number(reducedRow.wind.direction))) {
-            list.wind;
-              var _rest3 = _objectWithoutPropertiesLoose(list, _excluded5);
-            return _rest3;
-          }
-          return list;
-        }
-      case 'visibility':
-        {
-          // If empty, remove it from the list
-          if (!reducedRow.visibility.range && isNaN(reducedRow.visibility.range)) {
-            list.visibility;
-              var _rest4 = _objectWithoutPropertiesLoose(list, _excluded6);
-            return _rest4;
-          }
-          return list;
-        }
-      case 'change':
-      case 'probability':
-        // If empty, remove it from the list
-        if (!reducedRow[key]) {
-          list[key];
-            var _rest5 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
-          return _rest5;
-        }
-        return list;
-      case 'valid':
-        {
-          // If empty, remove it from the list
-          if (!reducedRow[key]) {
-            list[key];
-              var _rest6 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
-            return _rest6;
-          }
-          return list;
-        }
-      default:
-        {
-          return list;
-        }
-    }
-  }, reducedRow);
-}
-var convertTafValuesToObject = function convertTafValuesToObject(formData) {
-  formData.IS_DRAFT;
-    var productToPost = _objectWithoutPropertiesLoose(formData, _excluded7);
-  var tafStart = productToPost.validDateStart;
-  var tafEnd = productToPost.validDateEnd;
-  var parsedChangeGroups = productToPost.changeGroups && productToPost.changeGroups
-  // parse data for each changegroup row
-  .map(function (row) {
-    return parseFormValues(row, tafStart, tafEnd);
-  })
-  // filter out empty changegroup rows
-  .filter(function (value) {
-    return Object.keys(value).length;
-  });
-  var parsedBaseForecast = productToPost.baseForecast && parseFormValues(productToPost.baseForecast, tafStart, tafEnd);
-  var parsedFormValues = Object.assign({}, productToPost, {
-    baseForecast: parsedBaseForecast,
-    changeGroups: parsedChangeGroups
+    return -1;
   });
-  return Object.keys(parsedFormValues).reduce(function (list, key) {
-    switch (key) {
-      case 'changeGroups':
-        {
-          // remove changeGroups when empty
-          if (!parsedFormValues.changeGroups || !parsedFormValues.changeGroups.length) {
-            list.changeGroups;
-              var rest = _objectWithoutPropertiesLoose(list, _excluded8);
-            return rest;
-          }
-          return list;
-        }
-      case 'previousId':
-      case 'previousValidDateStart':
-      case 'previousValidDateEnd':
-      case 'issueDate':
-        {
-          // remove when empty
-          if (!parsedFormValues[key]) {
-            list[key];
-              var _rest7 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
-            return _rest7;
-          }
-          return list;
-        }
-      default:
-        {
-          return list;
-        }
-    }
-  }, parsedFormValues);
-};
-// Ensure we have enough data to retrieve a TAC - we only need to check for wind and visibility/ cavok as those are the only ones required in all cases
-var shouldRetrieveTAC = function shouldRetrieveTAC(product) {
-  if (product && product.baseForecast && product.baseForecast.wind && 'speed' in product.baseForecast.wind && product.baseForecast.wind.speed !== '' && (product.baseForecast.visibility && 'range' in product.baseForecast.visibility && product.baseForecast.visibility.range !== '' || product.baseForecast.cavOK)) {
-    return true;
-  }
-  return false;
 };
-var getFieldNames = function getFieldNames(isChangeGroup, index) {
-  var namePrefix = !isChangeGroup ? 'baseForecast' : "changeGroups[" + index + "]";
-  return Object.assign({}, !isChangeGroup && {
-    messageType: 'messageType',
-    location: 'location',
-    issueDate: 'issueDate'
-  }, isChangeGroup && {
-    probability: namePrefix + ".probability",
-    change: namePrefix + ".change"
-  }, {
-    valid: namePrefix + ".valid",
-    wind: namePrefix + ".wind",
-    visibility: namePrefix + ".visibility",
-    weather1: namePrefix + ".weather.weather1",
-    weather2: namePrefix + ".weather.weather2",
-    weather3: namePrefix + ".weather.weather3",
-    cloud1: namePrefix + ".cloud.cloud1",
-    cloud2: namePrefix + ".cloud.cloud2",
-    cloud3: namePrefix + ".cloud.cloud3",
-    cloud4: namePrefix + ".cloud.cloud4"
+var getBaseTime = function getBaseTime(baseTime, location) {
+  var currentBaseTime = dateUtils.utc(baseTime);
+  var activityPeriod = getLocationSetting(location).activity_period;
+  var nextBaseTime = dateUtils.add(dateUtils.utc(baseTime), {
+    hours: activityPeriod
   });
+  return {
+    currentBaseTime: currentBaseTime,
+    nextBaseTime: nextBaseTime
+  };
 };
-var tacHasError = function tacHasError(tac, t) {
-  return tac === t('TAC-missing-data') || tac === t('TAC-not-available') || tac === t('TAC-retrieving-data') || tac === t('TAC-failed');
+var getTafTimeSlot = function getTafTimeSlot(baseTime, location, status) {
+  var now = dateUtils.utc();
+  var _getBaseTime = getBaseTime(baseTime, location),
+    currentBaseTime = _getBaseTime.currentBaseTime,
+    nextBaseTime = _getBaseTime.nextBaseTime;
+  if (status === 'EXPIRED') {
+    return 'EXPIRED';
+  }
+  if (currentBaseTime.getTime() < now.getTime() && nextBaseTime.getTime() > now.getTime()) {
+    return 'ACTIVE';
+  }
+  return 'UPCOMING';
 };
-var useTACGenerator = function useTACGenerator(taf, requestTAC, getJSON) {
-  var _useTafTranslation = useTafTranslation(),
-    t = _useTafTranslation.t;
-  var _React$useState = React__default.useState(!taf || taf.status === 'NEW' ? t('TAC-not-available') : t('TAC-retrieving-data')),
-    TAC = _React$useState[0],
-    setTAC = _React$useState[1];
-  var _useIsMounted = useIsMounted(),
-    isMounted = _useIsMounted.isMounted;
-  var controller = React__default.useRef();
-  var onSetTac = function onSetTac(newTAC) {
-    if (controller.current) {
-      controller.current.abort();
-    }
-    setTAC(newTAC);
-  };
-  var retrieveTAC = React__default.useCallback(function (tafToPost) {
-    if (shouldRetrieveTAC(tafToPost)) {
-      if (controller.current) {
-        controller.current.abort();
-      }
-      controller.current = new AbortController();
-      setTAC(t('TAC-retrieving-data'));
-      requestTAC(tafToPost, getJSON, controller.current.signal).then(function (result) {
-        if (isMounted.current) {
-          setTAC(result.data);
-        }
-      })["catch"](function (error) {
-        if (isMounted && error.message !== 'canceled') {
-          setTAC(t('TAC-failed'));
-        }
-      });
+var sortTafTimeSlots = function sortTafTimeSlots(tafList) {
+  var sortedListOnIssueDate = sortTafsOnIssueDate(tafList);
+  var sortedListOnLocation = sortTafsOnLocation(sortedListOnIssueDate);
+  return sortedListOnLocation.reduce(function (sortedTafList, tafFromBackend) {
+    var taf = tafFromBackend.taf;
+    var timeSlot = getTafTimeSlot(taf.baseTime, taf.location, taf.status);
+    if (timeSlot === 'EXPIRED') {
+      sortedTafList.expired.push(tafFromBackend);
+    } else if (timeSlot === 'ACTIVE') {
+      sortedTafList.current.push(tafFromBackend);
     } else {
-      setTAC(t('TAC-missing-data'));
-    }
-  },
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  [isMounted, requestTAC, getJSON]);
-  React__default.useEffect(function () {
-    if (taf && taf.status !== 'NEW') {
-      retrieveTAC(taf);
+      sortedTafList.upcoming.push(tafFromBackend);
     }
-  }, [retrieveTAC, taf]);
-  return [TAC, retrieveTAC, onSetTac];
+    return sortedTafList;
+  }, {
+    current: [],
+    upcoming: [],
+    expired: []
+  });
 };
-var useDragOrder = function useDragOrder(trigger, move) {
-  var _React$useState2 = React__default.useState(null),
-    activeDraggingIndex = _React$useState2[0],
-    setActiveDraggingIndex = _React$useState2[1];
-  var _React$useState3 = React__default.useState([null, null]),
-    lastDragOrder = _React$useState3[0],
-    onUpdatelastDragOrder = _React$useState3[1];
-  var onChangeOrder = function onChangeOrder(_ref) {
-    var oldIndex = _ref.oldIndex,
-      newIndex = _ref.newIndex;
-    if (oldIndex === undefined || newIndex === undefined) {
-      return;
-    }
-    move(oldIndex, newIndex);
-    onUpdatelastDragOrder([oldIndex, newIndex]);
-    setActiveDraggingIndex(false);
-  };
-  var onStartDrag = function onStartDrag(_ref2) {
-    var oldIndex = _ref2.oldIndex;
-    return setActiveDraggingIndex(oldIndex);
-  };
-  // triggers validation AFTER render of new sorted elements
-  React__default.useEffect(function () {
-    var oldIndex = lastDragOrder[0],
-      newIndex = lastDragOrder[1];
-    if (oldIndex !== null && newIndex !== null) {
-      // trigger validation of all fields
-      void trigger();
-    }
-  }, [lastDragOrder, trigger]);
+var muiTabA11yProps = function muiTabA11yProps(index) {
   return {
-    onChangeOrder: onChangeOrder,
-    activeDraggingIndex: activeDraggingIndex,
-    onStartDrag: onStartDrag
+    id: "simple-tab-" + index,
+    'aria-controls': "simple-tabpanel-" + index
   };
 };
-// dialog utils
-var getConfirmationDialogTitle = function getConfirmationDialogTitle(action, t) {
-  if (action === 'CLEAR') {
-    return t('confirm-clear-title');
-  }
-  if (action === 'PUBLISH') {
-    return t('button-publish');
+var getNewTafLocationIndex = function getNewTafLocationIndex(tafLocations, previousTafLocationUUID) {
+  var newActiveIndexForDraft = tafLocations.findIndex(function (location) {
+    var _location$taf;
+    return (location == null || (_location$taf = location.taf) == null ? void 0 : _location$taf.previousId) === previousTafLocationUUID;
+  });
+  if (newActiveIndexForDraft !== -1) {
+    return newActiveIndexForDraft;
   }
-  if (action === 'AMEND') {
-    return t('confirm-amend-title');
+  var newActiveIndexForPublished = tafLocations.findIndex(function (location) {
+    var _location$taf2;
+    return (location == null || (_location$taf2 = location.taf) == null ? void 0 : _location$taf2.uuid) === previousTafLocationUUID;
+  });
+  if (newActiveIndexForPublished !== -1) {
+    return newActiveIndexForPublished;
   }
-  if (action === 'CORRECT') {
-    return t('confirm-correct-title');
+  return 0;
+};
+var getPreviousTaf = function getPreviousTaf(tafList, currentTaf) {
+  var previousId = currentTaf.taf.previousId;
+  if (!previousId) {
+    return null;
   }
-  if (action === 'CANCEL') {
-    return t('confirm-cancel-title');
+  var previousTaf = tafList.find(function (taf) {
+    return taf.taf.uuid === previousId;
+  });
+  return previousTaf ? previousTaf.taf : null;
+};
+var getAutoTafLocations = function getAutoTafLocations(autoTAFlocations) {
+  if (autoTAFlocations === void 0) {
+    autoTAFlocations = tafSettings.autoTAFlocations;
   }
-  return t('confirm-cancel-title');
+  return autoTAFlocations || null;
 };
-// Check if the amended/corrected TAF has been changed. Only compare the fields users are able to fill in
-// (i.e. exclude baseforecast valid time as that gets updated when doing an amendment automatically outside of the users influence)
-var isTafAmendedCorrectedChanged = function isTafAmendedCorrectedChanged(originalTaf, currentTaf) {
-  if (originalTaf === null || currentTaf === null) {
-    return false;
+var scrollToPosition = function scrollToPosition(scrollRef, activeLocation) {
+  if (!scrollRef.current) {
+    return;
   }
-  var originalBaseF = originalTaf.baseForecast,
-    originalChG = originalTaf.changeGroups;
-  var currentBaseF = currentTaf.baseForecast,
-    currentChG = currentTaf.changeGroups;
-  originalBaseF.valid;
-    var originalNoValid = _objectWithoutPropertiesLoose(originalBaseF, _excluded9);
-  currentBaseF.valid;
-    var currentNoValid = _objectWithoutPropertiesLoose(currentBaseF, _excluded10);
-  return !isEqual(originalNoValid, currentNoValid) || !isEqual(originalChG, currentChG);
+  var containerTop = scrollRef.current.getBoundingClientRect().top;
+  var firstLocation = scrollRef.current.querySelector("[data-location=\"" + activeLocation + "\"]");
+  var paddingTop = parseInt(getComputedStyle(scrollRef.current).paddingTop, 10);
+  var firstLocationTop = firstLocation == null ? void 0 : firstLocation.getBoundingClientRect().top;
+  var newScrollPosition = firstLocationTop - containerTop + scrollRef.current.scrollTop - paddingTop;
+  scrollRef.current.scrollTo(newScrollPosition, newScrollPosition);
 };
-var getConfirmationDialogContent = function getConfirmationDialogContent(action, isFormDirty, t) {
-  switch (action) {
-    case 'CLEAR':
-      return t('confirm-clear-content');
-    case 'PUBLISH':
-      return t('confirm-publish-content');
-    case 'AMEND':
-    case 'CORRECT':
-      return isFormDirty() ? t('confirm-correct-amend-content') : t('confirm-correct-amend-content-no-changes');
-    case 'CANCEL':
+var formatBaseTime = function formatBaseTime(time) {
+  return dateUtils.dateToString(time, DATE_FORMAT_BASE_TIME);
+};
+var getTafMessageContent = function getTafMessageContent(_ref5) {
+  var location = _ref5.location,
+    validDateStart = _ref5.validDateStart,
+    messageType = _ref5.messageType;
+  var formattedDate = formatBaseTime(dateUtils.utc(validDateStart));
+  return {
+    location: location,
+    formattedDate: formattedDate,
+    messageType: messageType
+  };
+};
+var getSnackbarMessage = function getSnackbarMessage(tafFromFrontEnd, isAutoSaved, t) {
+  var changeStatusTo = tafFromFrontEnd.changeStatusTo,
+    taf = tafFromFrontEnd.taf;
+  if (isAutoSaved) {
+    return t('snackbar-auto-save');
+  }
+  var content = getTafMessageContent(taf);
+  switch (changeStatusTo) {
+    case 'DRAFT':
+      return t('snackbar-draft');
+    case 'DRAFT_AMENDED':
+      return t('snackbar-draft-amend');
+    case 'DRAFT_CORRECTED':
+      return t('snackbar-draft-correct');
+    case 'PUBLISHED':
+      return t('snackbar-publish', content);
+    case 'CANCELLED':
+      return t('snackbar-cancel', content);
+    case 'CORRECTED':
+      return t('snackbar-correct', content);
+    case 'AMENDED':
+      return t('snackbar-amend', content);
     default:
-      return t('confirm-cancel-content');
+      return t('snackbar-save', content);
   }
 };
-var getConfirmationDialogButtonLabel = function getConfirmationDialogButtonLabel(action, t) {
-  switch (action) {
-    case 'CLEAR':
-      {
-        return t('button-clear');
+var isWarning = function isWarning(error) {
+  return (error == null ? void 0 : error.type) === 'WARNING';
+};
+var parseErrorMessage = function parseErrorMessage(error, params, t) {
+  var message = getErrorMessage$1(error);
+  var warningMessage = getWarningMessage(error);
+  if (warningMessage) {
+    return {
+      type: 'WARNING',
+      title: warningMessage
+    };
+  }
+  return params.changeStatusTo === 'CANCELLED' ? {
+    type: 'CANCELLED',
+    title: t('error-cancel'),
+    message: message
+  } : {
+    type: 'SERVER',
+    title: t('error-save'),
+    message: message
+  };
+};
+
+var useTafList = function useTafList(disabled) {
+  if (disabled === void 0) {
+    disabled = false;
+  }
+  return useAuthQuery(['taf-list'], getTafList, disabled, 1000 * 60 * 5);
+};
+var usePostTaf = function usePostTaf() {
+  var queryClient = useQueryClient();
+  var _useAuthenticationCon = useAuthenticationContext(),
+    auth = _useAuthenticationCon.auth;
+  var _useTafTranslation = useTafTranslation(),
+    t = _useTafTranslation.t;
+  var dispatch = useDispatch();
+  return useMutation({
+    mutationFn: function mutationFn(_ref) {
+      var tafData = _ref.tafData,
+        setError = _ref.setError;
+      if (!auth) {
+        throw new Error('Authentication context not found');
       }
-    case 'CANCEL':
-      return t('button-cancel');
-    default:
-      {
-        return t('button-publish');
+      setError(null);
+      return postTaf(auth, tafData);
+    },
+    onSuccess: function () {
+      var _onSuccess = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_data, _ref2) {
+        var tafData, isAutoSaved, message;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              tafData = _ref2.tafData, isAutoSaved = _ref2.isAutoSaved;
+              message = getSnackbarMessage(tafData, isAutoSaved, t);
+              dispatch(snackbarActions.openSnackbar({
+                type: snackbarTypes.SnackbarMessageType.VERBATIM_MESSAGE,
+                message: message
+              }));
+              // trigger refetch for the list
+              _context.next = 5;
+              return queryClient.invalidateQueries({
+                queryKey: ['taf-list']
+              });
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function onSuccess(_x, _x2) {
+        return _onSuccess.apply(this, arguments);
       }
-  }
+      return onSuccess;
+    }(),
+    onError: function () {
+      var _onError = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(error, _ref3) {
+        var tafData, setError, tafError;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              tafData = _ref3.tafData, setError = _ref3.setError;
+              tafError = parseErrorMessage(error, tafData, t);
+              setError(tafError);
+              if (!isWarning(tafError)) {
+                _context2.next = 6;
+                break;
+              }
+              _context2.next = 6;
+              return queryClient.invalidateQueries({
+                queryKey: ['taf-list']
+              });
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function onError(_x3, _x4) {
+        return _onError.apply(this, arguments);
+      }
+      return onError;
+    }()
+  });
 };
-var emptyChangegroup = {
-  valid: '',
+var usePatchTaf = function usePatchTaf() {
+  var queryClient = useQueryClient();
+  var _useAuthenticationCon2 = useAuthenticationContext(),
+    auth = _useAuthenticationCon2.auth;
+  var _useTafTranslation2 = useTafTranslation(),
+    t = _useTafTranslation2.t;
+  return useMutation({
+    mutationFn: function mutationFn(_ref4) {
+      var tafData = _ref4.tafData,
+        setError = _ref4.setError;
+      if (!auth) {
+        throw new Error('Authentication context not found');
+      }
+      setError(null);
+      return patchTaf(auth, tafData);
+    },
+    onSuccess: function () {
+      var _onSuccess2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return queryClient.invalidateQueries({
+                queryKey: ['taf-list']
+              });
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function onSuccess() {
+        return _onSuccess2.apply(this, arguments);
+      }
+      return onSuccess;
+    }(),
+    onError: function onError(error, _ref5) {
+      var tafData = _ref5.tafData,
+        setError = _ref5.setError;
+      var newError = parseErrorMessage(error, tafData, t);
+      setError(newError);
+    }
+  });
+};
+var useGetTAC = function useGetTAC() {
+  var _useAuthenticationCon3 = useAuthenticationContext(),
+    auth = _useAuthenticationCon3.auth;
+  return useMutation({
+    mutationFn: function mutationFn(_ref6) {
+      var tafData = _ref6.tafData;
+      if (!auth) {
+        throw new Error('Authentication context not found');
+      }
+      return getTAC(auth, tafData);
+    }
+  });
+};
+
+var _excluded$5 = ["cavOK"],
+  _excluded2 = ["visibility"],
+  _excluded3 = ["cloud"],
+  _excluded4 = ["weather"],
+  _excluded5 = ["wind"],
+  _excluded6 = ["visibility"],
+  _excluded7 = ["IS_DRAFT"],
+  _excluded8 = ["changeGroups"],
+  _excluded9 = ["valid"],
+  _excluded10 = ["valid"];
+var emptyBaseForecast = {
   wind: '',
   visibility: '',
   weather: {
@@ -3051,93 +3083,502 @@ var emptyChangegroup = {
     cloud2: '',
     cloud3: '',
     cloud4: ''
-  },
-  change: '',
-  probability: ''
-};
-var getTafStatusLabel = function getTafStatusLabel(t, status, action, isFormDisabled) {
-  // See if we need to base status label on action if form is not disabled and action passed
-  var baseOnAction = isFormDisabled !== undefined && !isFormDisabled && action;
-  if (baseOnAction && action === 'AMEND' && (status === 'PUBLISHED' || status === 'AMENDED' || status === 'CORRECTED')) {
-    return t('status-new-amendment');
-  }
-  if (baseOnAction && action === 'CORRECT' && (status === 'PUBLISHED' || status === 'AMENDED' || status === 'CORRECTED')) {
-    return t('status-new-correction');
-  }
-  switch (status) {
-    case 'DRAFT_AMENDED':
-      return t('status-draft-amendment');
-    case 'DRAFT_CORRECTED':
-      return t('status-draft-correction');
-    case 'AMENDED':
-      return t('status-published-amendment');
-    case 'CORRECTED':
-      return t('status-published-correction');
-    default:
-      return t("status-" + status.toLocaleLowerCase());
   }
 };
-var getMessageType = function getMessageType(taf, tafAction) {
-  if (tafAction === 'CORRECT') {
-    return 'COR';
-  }
-  if (tafAction === 'AMEND') {
-    return 'AMD';
-  }
-  if (tafAction === 'CANCEL') {
-    return 'CNL';
-  }
-  return taf.messageType;
+var MIN_NUMBER_CHANGE_GROUP = 5;
+// formatters
+var formatIssueTime = function formatIssueTime(issueDate) {
+  var issueDateAsString = dateUtils.dateToString(new Date(issueDate), DATE_FORMAT_ISSUE_TIME);
+  return issueDateAsString || 'Not issued';
 };
-// For corrections and amendment we need to add the previousValidStart and End for the TAC converter
-var getAmendedCorrectedTafTimes = function getAmendedCorrectedTafTimes(taf, tafAction) {
-  var previousValidDateStart = taf.previousValidDateStart && tafAction !== 'AMEND' ? taf.previousValidDateStart : taf.validDateStart;
-  var previousValidDateEnd = taf.previousValidDateEnd && tafAction !== 'AMEND' ? taf.previousValidDateEnd : taf.validDateEnd;
-  // For amendment change valid start time to current time
-  // only do this if we're already within the validity period
-  var now = dateUtils.utc();
-  var validDateStart = dateUtils.utc(taf.validDateStart);
-  if ((tafAction === 'AMEND' || tafAction === 'DRAFT_AMEND') && now.getTime() >= validDateStart.getTime()) {
-    var _now = dateUtils.dateToString(dateUtils.utc(), dateUtils.DATE_FORMAT_UTC);
-    var validObj = {
-      start: _now,
-      end: taf.baseForecast.valid.end
-    };
-    return Object.assign({}, taf, {
-      previousValidDateStart: previousValidDateStart,
-      previousValidDateEnd: previousValidDateEnd,
-      validDateStart: _now,
-      baseForecast: Object.assign({}, taf.baseForecast, {
-        valid: validObj
-      })
-    });
-  }
-  return Object.assign({}, taf, {
-    previousValidDateStart: previousValidDateStart,
-    previousValidDateEnd: previousValidDateEnd
+function formatFormValues(row) {
+  return Object.keys(row).reduce(function (list, key) {
+    switch (key) {
+      case 'valid':
+        {
+          return Object.assign({}, list, {
+            valid: formatValidToString(list[key])
+          });
+        }
+      case 'wind':
+        {
+          return Object.assign({}, list, {
+            wind: formatWindToString(list[key])
+          });
+        }
+      case 'visibility':
+        {
+          // Assume if visibility field set - no cavOK
+          return Object.assign({}, list, {
+            visibility: formatVisibilityToString(list[key])
+          });
+        }
+      case 'cavOK':
+        {
+          // Assume if cavOK field set to true - no visibility field, otherwise return the original list containing the visibility and remove cavOK
+          list.cavOK;
+            var formData = _objectWithoutPropertiesLoose(list, _excluded$5);
+          if (list[key]) {
+            return Object.assign({}, formData, {
+              visibility: formatVisibilityToString(list[key])
+            });
+          }
+          return formData;
+        }
+      case 'cloud':
+        {
+          return Object.assign({}, list, {
+            cloud: formatCloudsToString(list[key])
+          });
+        }
+      default:
+        {
+          return list;
+        }
+    }
+  }, row);
+}
+// parsers
+function reduceRowValues(row, tafStart, tafEnd) {
+  return Object.keys(row).reduce(function (list, key) {
+    switch (key) {
+      case 'valid':
+        {
+          return Object.assign({}, list, {
+            valid: parseValidToObject(list[key], tafStart, tafEnd)
+          });
+        }
+      case 'wind':
+        {
+          return Object.assign({}, list, {
+            wind: parseWindToObject(list[key])
+          });
+        }
+      case 'visibility':
+        {
+          return Object.assign({}, list, parseVisibilityToObject(list[key]));
+        }
+      case 'weather':
+        {
+          return Object.assign({}, list, {
+            weather: parseWeatherToObject(list[key])
+          });
+        }
+      case 'cloud':
+        {
+          return Object.assign({}, list, {
+            cloud: parseCloudsToObject(list[key])
+          });
+        }
+      // Trim string field
+      case 'change':
+      case 'probability':
+        {
+          var _Object$assign;
+          return Object.assign({}, list, (_Object$assign = {}, _Object$assign[key] = String(list[key]).trim(), _Object$assign));
+        }
+      default:
+        {
+          return list;
+        }
+    }
+  }, row);
+}
+function parseFormValues(row, tafStart, tafEnd) {
+  var reducedRow = reduceRowValues(row, tafStart, tafEnd);
+  return Object.keys(reducedRow).reduce(function (list, key) {
+    switch (key) {
+      case 'cavOK':
+        {
+          // if cavOK is set - remove visibility from the list
+          if (reducedRow.cavOK) {
+            list.visibility;
+              var rest = _objectWithoutPropertiesLoose(list, _excluded2);
+            return rest;
+          }
+          return list;
+        }
+      case 'cloud':
+        {
+          // If cloud is undefined or empty, remove it from the list
+          if (!reducedRow.cloud || Object.keys(reducedRow.cloud).length === 0) {
+            list.cloud;
+              var _rest = _objectWithoutPropertiesLoose(list, _excluded3);
+            return _rest;
+          }
+          return list;
+        }
+      case 'weather':
+        {
+          // If empty, remove it from the list
+          if (!reducedRow.weather.weather1) {
+            list.weather;
+              var _rest2 = _objectWithoutPropertiesLoose(list, _excluded4);
+            return _rest2;
+          }
+          return list;
+        }
+      case 'wind':
+        {
+          // If empty, remove it from the list
+          if (!reducedRow.wind.direction && isNaN(Number(reducedRow.wind.direction))) {
+            list.wind;
+              var _rest3 = _objectWithoutPropertiesLoose(list, _excluded5);
+            return _rest3;
+          }
+          return list;
+        }
+      case 'visibility':
+        {
+          // If empty, remove it from the list
+          if (!reducedRow.visibility.range && isNaN(reducedRow.visibility.range)) {
+            list.visibility;
+              var _rest4 = _objectWithoutPropertiesLoose(list, _excluded6);
+            return _rest4;
+          }
+          return list;
+        }
+      case 'change':
+      case 'probability':
+        // If empty, remove it from the list
+        if (!reducedRow[key]) {
+          list[key];
+            var _rest5 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
+          return _rest5;
+        }
+        return list;
+      case 'valid':
+        {
+          // If empty, remove it from the list
+          if (!reducedRow[key]) {
+            list[key];
+              var _rest6 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
+            return _rest6;
+          }
+          return list;
+        }
+      default:
+        {
+          return list;
+        }
+    }
+  }, reducedRow);
+}
+var convertTafValuesToObject = function convertTafValuesToObject(formData) {
+  formData.IS_DRAFT;
+    var productToPost = _objectWithoutPropertiesLoose(formData, _excluded7);
+  var tafStart = productToPost.validDateStart;
+  var tafEnd = productToPost.validDateEnd;
+  var parsedChangeGroups = productToPost.changeGroups && productToPost.changeGroups
+  // parse data for each changegroup row
+  .map(function (row) {
+    return parseFormValues(row, tafStart, tafEnd);
+  })
+  // filter out empty changegroup rows
+  .filter(function (value) {
+    return Object.keys(value).length;
   });
-};
-var createChangeGroup = function createChangeGroup(changeGroup) {
-  return Object.assign({}, emptyChangegroup, changeGroup, {
-    weather: Object.assign({}, emptyChangegroup.weather, changeGroup.weather),
-    cloud: Object.assign({}, emptyChangegroup.cloud, changeGroup.cloud)
+  var parsedBaseForecast = productToPost.baseForecast && parseFormValues(productToPost.baseForecast, tafStart, tafEnd);
+  var parsedFormValues = Object.assign({}, productToPost, {
+    baseForecast: parsedBaseForecast,
+    changeGroups: parsedChangeGroups
   });
+  return Object.keys(parsedFormValues).reduce(function (list, key) {
+    switch (key) {
+      case 'changeGroups':
+        {
+          // remove changeGroups when empty
+          if (!parsedFormValues.changeGroups || !parsedFormValues.changeGroups.length) {
+            list.changeGroups;
+              var rest = _objectWithoutPropertiesLoose(list, _excluded8);
+            return rest;
+          }
+          return list;
+        }
+      case 'previousId':
+      case 'previousValidDateStart':
+      case 'previousValidDateEnd':
+      case 'issueDate':
+        {
+          // remove when empty
+          if (!parsedFormValues[key]) {
+            list[key];
+              var _rest7 = _objectWithoutPropertiesLoose(list, [key].map(_toPropertyKey));
+            return _rest7;
+          }
+          return list;
+        }
+      default:
+        {
+          return list;
+        }
+    }
+  }, parsedFormValues);
 };
-var prepareTafValues = function prepareTafValues(_taf, tafAction, addEmptyChangeGroups) {
-  var _taf$changeGroups, _Object$assign2;
-  if (addEmptyChangeGroups === void 0) {
-    addEmptyChangeGroups = false;
+// Ensure we have enough data to retrieve a TAC - we only need to check for wind and visibility/ cavok as those are the only ones required in all cases
+var shouldRetrieveTAC = function shouldRetrieveTAC(product) {
+  if (product && product.baseForecast && product.baseForecast.wind && 'speed' in product.baseForecast.wind && product.baseForecast.wind.speed !== '' && (product.baseForecast.visibility && 'range' in product.baseForecast.visibility && product.baseForecast.visibility.range !== '' || product.baseForecast.cavOK)) {
+    return true;
   }
-  // If action is AMEND/CORRECT/DRAFT_AMEND/DRAFT_CORRECTION - add previous valid start and end
-  // If action is AMEND/DRAFT_AMEND - update validity start time to current time
-  var taf = tafAction === 'AMEND' || tafAction === 'DRAFT_AMEND' || tafAction === 'CORRECT' || tafAction === 'DRAFT_CORRECT' ? getAmendedCorrectedTafTimes(_taf, tafAction) : _taf;
-  var formattedBaseForecast = formatFormValues(taf.baseForecast);
-  var baseForecast = Object.assign({}, emptyBaseForecast, formattedBaseForecast, {
-    weather: Object.assign({}, emptyBaseForecast.weather, formattedBaseForecast.weather),
-    cloud: Object.assign({}, emptyBaseForecast.cloud, formattedBaseForecast.cloud)
-  });
-  var formattedChangeGroups = ((_taf$changeGroups = taf.changeGroups) == null ? void 0 : _taf$changeGroups.map(formatFormValues)) || [];
-  var changeGroups = formattedChangeGroups.map(createChangeGroup);
+  return false;
+};
+var getFieldNames = function getFieldNames(isChangeGroup, index) {
+  var namePrefix = !isChangeGroup ? 'baseForecast' : "changeGroups[" + index + "]";
+  return Object.assign({}, !isChangeGroup && {
+    messageType: 'messageType',
+    location: 'location',
+    issueDate: 'issueDate'
+  }, isChangeGroup && {
+    probability: namePrefix + ".probability",
+    change: namePrefix + ".change"
+  }, {
+    valid: namePrefix + ".valid",
+    wind: namePrefix + ".wind",
+    visibility: namePrefix + ".visibility",
+    weather1: namePrefix + ".weather.weather1",
+    weather2: namePrefix + ".weather.weather2",
+    weather3: namePrefix + ".weather.weather3",
+    cloud1: namePrefix + ".cloud.cloud1",
+    cloud2: namePrefix + ".cloud.cloud2",
+    cloud3: namePrefix + ".cloud.cloud3",
+    cloud4: namePrefix + ".cloud.cloud4"
+  });
+};
+var tacHasError = function tacHasError(tac, t) {
+  return tac === t('TAC-missing-data') || tac === t('TAC-not-available') || tac === t('TAC-retrieving-data') || tac === t('TAC-failed');
+};
+var useTACGenerator = function useTACGenerator(taf) {
+  var _useTafTranslation = useTafTranslation(),
+    t = _useTafTranslation.t;
+  var _useGetTAC = useGetTAC(),
+    requestTAC = _useGetTAC.mutateAsync;
+  var _React$useState = React__default.useState(!taf || taf.status === 'NEW' ? t('TAC-not-available') : t('TAC-retrieving-data')),
+    TAC = _React$useState[0],
+    setTAC = _React$useState[1];
+  var retrieveTAC = React__default.useCallback(function (tafToPost) {
+    if (shouldRetrieveTAC(tafToPost)) {
+      setTAC(t('TAC-retrieving-data'));
+      requestTAC({
+        tafData: tafToPost
+      }).then(function (result) {
+        setTAC(result);
+      })["catch"](function () {
+        setTAC(t('TAC-failed'));
+      });
+    } else {
+      setTAC(t('TAC-missing-data'));
+    }
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [requestTAC]);
+  React__default.useEffect(function () {
+    if (taf && taf.status !== 'NEW') {
+      retrieveTAC(taf);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [taf]);
+  return [TAC, retrieveTAC];
+};
+var useDragOrder = function useDragOrder(trigger, move) {
+  var _React$useState2 = React__default.useState(null),
+    activeDraggingIndex = _React$useState2[0],
+    setActiveDraggingIndex = _React$useState2[1];
+  var _React$useState3 = React__default.useState([null, null]),
+    lastDragOrder = _React$useState3[0],
+    onUpdatelastDragOrder = _React$useState3[1];
+  var onChangeOrder = function onChangeOrder(_ref) {
+    var oldIndex = _ref.oldIndex,
+      newIndex = _ref.newIndex;
+    if (oldIndex === undefined || newIndex === undefined) {
+      return;
+    }
+    move(oldIndex, newIndex);
+    onUpdatelastDragOrder([oldIndex, newIndex]);
+    setActiveDraggingIndex(false);
+  };
+  var onStartDrag = function onStartDrag(_ref2) {
+    var oldIndex = _ref2.oldIndex;
+    return setActiveDraggingIndex(oldIndex);
+  };
+  // triggers validation AFTER render of new sorted elements
+  React__default.useEffect(function () {
+    var oldIndex = lastDragOrder[0],
+      newIndex = lastDragOrder[1];
+    if (oldIndex !== null && newIndex !== null) {
+      // trigger validation of all fields
+      void trigger();
+    }
+  }, [lastDragOrder, trigger]);
+  return {
+    onChangeOrder: onChangeOrder,
+    activeDraggingIndex: activeDraggingIndex,
+    onStartDrag: onStartDrag
+  };
+};
+// dialog utils
+var getConfirmationDialogTitle = function getConfirmationDialogTitle(action, t) {
+  if (action === 'CLEAR') {
+    return t('confirm-clear-title');
+  }
+  if (action === 'PUBLISH') {
+    return t('button-publish');
+  }
+  if (action === 'AMEND') {
+    return t('confirm-amend-title');
+  }
+  if (action === 'CORRECT') {
+    return t('confirm-correct-title');
+  }
+  if (action === 'CANCEL') {
+    return t('confirm-cancel-title');
+  }
+  return t('confirm-cancel-title');
+};
+// Check if the amended/corrected TAF has been changed. Only compare the fields users are able to fill in
+// (i.e. exclude baseforecast valid time as that gets updated when doing an amendment automatically outside of the users influence)
+var isTafAmendedCorrectedChanged = function isTafAmendedCorrectedChanged(originalTaf, currentTaf) {
+  if (originalTaf === null || currentTaf === null) {
+    return false;
+  }
+  var originalBaseF = originalTaf.baseForecast,
+    originalChG = originalTaf.changeGroups;
+  var currentBaseF = currentTaf.baseForecast,
+    currentChG = currentTaf.changeGroups;
+  originalBaseF.valid;
+    var originalNoValid = _objectWithoutPropertiesLoose(originalBaseF, _excluded9);
+  currentBaseF.valid;
+    var currentNoValid = _objectWithoutPropertiesLoose(currentBaseF, _excluded10);
+  return !isEqual(originalNoValid, currentNoValid) || !isEqual(originalChG, currentChG);
+};
+var getConfirmationDialogContent = function getConfirmationDialogContent(action, isFormDirty, t) {
+  switch (action) {
+    case 'CLEAR':
+      return t('confirm-clear-content');
+    case 'PUBLISH':
+      return t('confirm-publish-content');
+    case 'AMEND':
+    case 'CORRECT':
+      return isFormDirty() ? t('confirm-correct-amend-content') : t('confirm-correct-amend-content-no-changes');
+    case 'CANCEL':
+    default:
+      return t('confirm-cancel-content');
+  }
+};
+var getConfirmationDialogButtonLabel = function getConfirmationDialogButtonLabel(action, t) {
+  switch (action) {
+    case 'CLEAR':
+      {
+        return t('button-clear');
+      }
+    case 'CANCEL':
+      return t('button-cancel');
+    default:
+      {
+        return t('button-publish');
+      }
+  }
+};
+var emptyChangegroup = {
+  valid: '',
+  wind: '',
+  visibility: '',
+  weather: {
+    weather1: '',
+    weather2: '',
+    weather3: ''
+  },
+  cloud: {
+    cloud1: '',
+    cloud2: '',
+    cloud3: '',
+    cloud4: ''
+  },
+  change: '',
+  probability: ''
+};
+var getTafStatusLabel = function getTafStatusLabel(t, status, action, isFormDisabled) {
+  // See if we need to base status label on action if form is not disabled and action passed
+  var baseOnAction = isFormDisabled !== undefined && !isFormDisabled && action;
+  if (baseOnAction && action === 'AMEND' && (status === 'PUBLISHED' || status === 'AMENDED' || status === 'CORRECTED')) {
+    return t('status-new-amendment');
+  }
+  if (baseOnAction && action === 'CORRECT' && (status === 'PUBLISHED' || status === 'AMENDED' || status === 'CORRECTED')) {
+    return t('status-new-correction');
+  }
+  switch (status) {
+    case 'DRAFT_AMENDED':
+      return t('status-draft-amendment');
+    case 'DRAFT_CORRECTED':
+      return t('status-draft-correction');
+    case 'AMENDED':
+      return t('status-published-amendment');
+    case 'CORRECTED':
+      return t('status-published-correction');
+    default:
+      return t("status-" + status.toLocaleLowerCase());
+  }
+};
+var getMessageType = function getMessageType(taf, tafAction) {
+  if (tafAction === 'CORRECT') {
+    return 'COR';
+  }
+  if (tafAction === 'AMEND') {
+    return 'AMD';
+  }
+  if (tafAction === 'CANCEL') {
+    return 'CNL';
+  }
+  return taf.messageType;
+};
+// For corrections and amendment we need to add the previousValidStart and End for the TAC converter
+var getAmendedCorrectedTafTimes = function getAmendedCorrectedTafTimes(taf, tafAction) {
+  var previousValidDateStart = taf.previousValidDateStart && tafAction !== 'AMEND' ? taf.previousValidDateStart : taf.validDateStart;
+  var previousValidDateEnd = taf.previousValidDateEnd && tafAction !== 'AMEND' ? taf.previousValidDateEnd : taf.validDateEnd;
+  // For amendment change valid start time to current time
+  // only do this if we're already within the validity period
+  var now = dateUtils.utc();
+  var validDateStart = dateUtils.utc(taf.validDateStart);
+  if ((tafAction === 'AMEND' || tafAction === 'DRAFT_AMEND') && now.getTime() >= validDateStart.getTime()) {
+    var _now = dateUtils.dateToString(dateUtils.utc(), dateUtils.DATE_FORMAT_UTC);
+    var validObj = {
+      start: _now,
+      end: taf.baseForecast.valid.end
+    };
+    return Object.assign({}, taf, {
+      previousValidDateStart: previousValidDateStart,
+      previousValidDateEnd: previousValidDateEnd,
+      validDateStart: _now,
+      baseForecast: Object.assign({}, taf.baseForecast, {
+        valid: validObj
+      })
+    });
+  }
+  return Object.assign({}, taf, {
+    previousValidDateStart: previousValidDateStart,
+    previousValidDateEnd: previousValidDateEnd
+  });
+};
+var createChangeGroup = function createChangeGroup(changeGroup) {
+  return Object.assign({}, emptyChangegroup, changeGroup, {
+    weather: Object.assign({}, emptyChangegroup.weather, changeGroup.weather),
+    cloud: Object.assign({}, emptyChangegroup.cloud, changeGroup.cloud)
+  });
+};
+var prepareTafValues = function prepareTafValues(_taf, tafAction, addEmptyChangeGroups) {
+  var _taf$changeGroups, _Object$assign2;
+  if (addEmptyChangeGroups === void 0) {
+    addEmptyChangeGroups = false;
+  }
+  // If action is AMEND/CORRECT/DRAFT_AMEND/DRAFT_CORRECTION - add previous valid start and end
+  // If action is AMEND/DRAFT_AMEND - update validity start time to current time
+  var taf = tafAction === 'AMEND' || tafAction === 'DRAFT_AMEND' || tafAction === 'CORRECT' || tafAction === 'DRAFT_CORRECT' ? getAmendedCorrectedTafTimes(_taf, tafAction) : _taf;
+  var formattedBaseForecast = formatFormValues(taf.baseForecast);
+  var baseForecast = Object.assign({}, emptyBaseForecast, formattedBaseForecast, {
+    weather: Object.assign({}, emptyBaseForecast.weather, formattedBaseForecast.weather),
+    cloud: Object.assign({}, emptyBaseForecast.cloud, formattedBaseForecast.cloud)
+  });
+  var formattedChangeGroups = ((_taf$changeGroups = taf.changeGroups) == null ? void 0 : _taf$changeGroups.map(formatFormValues)) || [];
+  var changeGroups = formattedChangeGroups.map(createChangeGroup);
   // If addEmptyChangeGroups is true - ensure there are at least MIN_NUMBER_CHANGE_GROUP changegroups
   if (addEmptyChangeGroups) {
     var changeGroupsToAdd = MIN_NUMBER_CHANGE_GROUP - changeGroups.length;
@@ -3158,15 +3599,28 @@ var prepareTafValues = function prepareTafValues(_taf, tafAction, addEmptyChange
     changeGroups: changeGroups
   }, _Object$assign2[HIDDEN_INPUT_HELPER_IS_DRAFT] = true, _Object$assign2));
 };
-var clearTafFormData = function clearTafFormData(tafFormValues) {
-  // Remove all except for the validity times
-  var baseForecast = {
-    valid: tafFormValues.baseForecast.valid
-  };
-  var emptyChangeGroups = [];
-  Array.from(Array(MIN_NUMBER_CHANGE_GROUP)).map(function () {
-    return emptyChangeGroups.push(emptyChangegroup);
-  });
+var prepareTafExportValues = function prepareTafExportValues(tafToCopy, currentTaf) {
+  var _currentTaf$baseForec;
+  var convertedCopy = prepareTafValues(tafToCopy, undefined, false);
+  var baseForecast = convertedCopy.baseForecast,
+    _convertedCopy$change = convertedCopy.changeGroups,
+    changeGroups = _convertedCopy$change === void 0 ? [] : _convertedCopy$change;
+  return Object.assign({}, currentTaf, {
+    baseForecast: Object.assign({}, baseForecast, {
+      valid: currentTaf == null || (_currentTaf$baseForec = currentTaf.baseForecast) == null ? void 0 : _currentTaf$baseForec.valid
+    }),
+    changeGroups: changeGroups
+  });
+};
+var clearTafFormData = function clearTafFormData(tafFormValues) {
+  // Remove all except for the validity times
+  var baseForecast = {
+    valid: tafFormValues.baseForecast.valid
+  };
+  var emptyChangeGroups = [];
+  Array.from(Array(MIN_NUMBER_CHANGE_GROUP)).map(function () {
+    return emptyChangeGroups.push(emptyChangegroup);
+  });
   return Object.assign({}, tafFormValues, {
     baseForecast: Object.assign({}, emptyBaseForecast, baseForecast),
     // Add empty change groups
@@ -4348,55 +4802,6 @@ var TafFormRow = /*#__PURE__*/React__default.forwardRef(function (_ref, ref) {
   }));
 });
 
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2025 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2025 - Finnish Meteorological Institute (FMI)
- * Copyright 2025 - The Norwegian Meteorological Institute (MET Norway)
- * */
-var config = getConfig();
-var tafBaseUrl = config.GW_TAF_BASE_URL || '';
-var getTafList = function getTafList(auth) {
-  return fetch(tafBaseUrl + "/taflist", {
-    headers: getHeaders(auth)
-  }).then(handleResponse);
-};
-
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2025 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2025 - Finnish Meteorological Institute (FMI)
- * Copyright 2025 - The Norwegian Meteorological Institute (MET Norway)
- * */
-var useTafList = function useTafList(disabled) {
-  if (disabled === void 0) {
-    disabled = false;
-  }
-  return useAuthQuery(['taf-list'], getTafList, disabled, 1000 * 60 * 5);
-};
-
 // prevents default functionality
 var noop = function noop() {};
 var TafForm = /*#__PURE__*/React__default.memo(function (_ref) {
@@ -4428,7 +4833,7 @@ var TafForm = /*#__PURE__*/React__default.memo(function (_ref) {
   var formRef = React__default.useRef(null);
   var originalTaf = tafFromBackend.taf,
     editor = tafFromBackend.editor;
-  var _useAuthenticationCon = useAuthenticationContext(),
+  var _useAuthenticationCon = useAuthenticationContext$1(),
     auth = _useAuthenticationCon.auth;
   var dispatch = useDispatch();
   var isEditor = editor === (auth == null ? void 0 : auth.username) || false;
@@ -4715,493 +5120,276 @@ var TafForm = /*#__PURE__*/React__default.memo(function (_ref) {
         break;
       default:
         resetFormState(false, action);
-        break;
-    }
-  };
-  var onRemoverow = function onRemoverow(index) {
-    void confirmDialog({
-      title: t('options-delete'),
-      description: t('confirm-delete-description'),
-      confirmLabel: t('confirm-yes')
-    }).then(function () {
-      remove(index);
-      void trigger(); // trigger all fields validation
-    });
-  };
-  // TODO: https://gitlab.com/opengeoweb/opengeoweb/-/issues/726 insert (react-hook-form) does not work well with focus (only last row will get focus), so added this dirty solution. This can be fixed in a better way in react-hook-form v7
-  var focusFirstInput = function focusFirstInput(rowIndex) {
-    var selector = rowIndex === -1 ? "[name=\"baseForecast.wind\"]" : "[name=\"changeGroups[" + rowIndex + "].probability\"]";
-    var nextRowFirstInput = document.querySelector(selector);
-    if (nextRowFirstInput) {
-      nextRowFirstInput.focus();
-    }
-  };
-  // adding rows and validation don't work well combined, with always skipping validation of fields of rows above the one the inserted row. A setTimeout prevents this issue
-  var setFocusAndValidate = function setFocusAndValidate(rowIndex) {
-    return setTimeout(function () {
-      focusFirstInput(rowIndex);
-      void trigger(); // trigger all fields validation
-    }, 0);
-  };
-  var onAddRow = function onAddRow(rowIndex, above) {
-    if (rowIndex === void 0) {
-      rowIndex = -1;
-    }
-    if (above === void 0) {
-      above = false;
-    }
-    var newRowIndex = above ? rowIndex : rowIndex + 1;
-    insert(newRowIndex, emptyChangegroup, {
-      shouldFocus: false
-    });
-    setFocusAndValidate(newRowIndex);
-  };
-  var _onClearRow = function onClearRow(rowIndex, isChangeGroup) {
-    if (rowIndex === void 0) {
-      rowIndex = -1;
-    }
-    if (isChangeGroup === void 0) {
-      isChangeGroup = false;
-    }
-    void confirmDialog({
-      title: t('options-clear'),
-      description: t('confirm-clear-description'),
-      confirmLabel: t('confirm-yes')
-    }).then(function () {
-      if (isChangeGroup) {
-        remove(rowIndex);
-        insert(rowIndex, emptyChangegroup, {
-          shouldFocus: false
-        });
-      } else {
-        var baseForecastFields = getFieldNames(false, -1);
-        setValue(baseForecastFields.wind, '');
-        setValue(baseForecastFields.visibility, '');
-        setValue(baseForecastFields.weather1, '');
-        setValue(baseForecastFields.weather2, '');
-        setValue(baseForecastFields.weather3, '');
-        setValue(baseForecastFields.cloud1, '');
-        setValue(baseForecastFields.cloud2, '');
-        setValue(baseForecastFields.cloud3, '');
-        setValue(baseForecastFields.cloud4, '');
-      }
-      setFocusAndValidate(rowIndex);
-    });
-  };
-  var _React$useState = React__default.useState(false),
-    shouldValidate = _React$useState[0],
-    setShouldValidate = _React$useState[1];
-  React__default.useEffect(function () {
-    setIsDisabled(!isEditor || isDefaultDisabled);
-    // set validate flag to validate after the values have been set
-    setShouldValidate(true);
-    // register validate method to use in parent components
-    var onValidateFormPromise = function onValidateFormPromise() {
-      return new Promise(function (resolve, reject) {
-        toggleIsDraft(true);
-        void handleSubmit(function (formData) {
-          resolve(convertTafValuesToObject(formData));
-        })().then(function (formData) {
-          if (formData === undefined) {
-            reject();
-          }
-          resolve(formData);
-        });
-      });
-    };
-    if (registerValidateForm) {
-      registerValidateForm(onValidateFormPromise);
-    }
-    // set default taf action
-    if (setTafAction) {
-      setTafAction(fromStatusToAction(originalTaf.status));
-    }
-    return function () {
-      resetFormValues({});
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-  React__default.useEffect(function () {
-    var newValues = prepareTafValues(originalTaf, undefined, !isDefaultDisabled);
-    // set new form values when taf values changed
-    resetFormValues(newValues);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [originalTaf]);
-  React__default.useEffect(function () {
-    // update disabled state when editor changed
-    setIsDisabled(!isEditor || isDefaultDisabled);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [editor]);
-  React__default.useEffect(function () {
-    if (shouldValidate && !isDisabled) {
-      // trigger validation on all changegroup validity times after form is enabled since they could be outside the new validity period
-      var _originalTaf$changeGr = originalTaf.changeGroups,
-        changeGroups = _originalTaf$changeGr === void 0 ? [] : _originalTaf$changeGr;
-      var validFields = changeGroups.map(function (_field, index) {
-        return "changeGroups[" + index + "].valid";
-      });
-      void trigger(validFields);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [shouldValidate, isDisabled]);
-  return jsxs(Fragment, {
-    children: [jsxs(Box, {
-      sx: {
-        display: 'flex',
-        flexDirection: 'row',
-        alignItems: 'center',
-        position: 'absolute',
-        top: {
-          xs: '34px',
-          sm: '-3px'
-        },
-        right: {
-          xs: 'calc(50% -  70px)',
-          sm: '8px'
-        }
-      },
-      children: [jsx(SwitchButton, {
-        checked: isEditor,
-        onChange: onSwitchMode
-      }), jsx(Box, {
-        sx: {
-          width: '16px',
-          marginLeft: 1
-        },
-        children: editor && jsx(TafAvatar, {
-          editor: editor
-        })
-      })]
-    }), jsxs("form", {
-      "data-testid": "taf-form",
-      onSubmit: handleSubmit(onSubmit),
-      ref: formRef,
-      children: [jsx(TafFormRow, {
-        disabled: isDisabled,
-        onAddChangeGroupBelow: onAddRow,
-        onClearRow: _onClearRow,
-        isNotRequiredForAction: isNotRequiredForAction
-      }), jsx(ReactSortable, {
-        tag: "div",
-        list: fields,
-        setList: noop,
-        animation: 200,
-        onSort: onChangeOrder,
-        handle: ".handle",
-        direction: "vertical",
-        // hover props
-        forceFallback: false,
-        onStart: function onStart(event) {
-          onStartDrag(event);
-          if (Sortable.ghost) {
-            Sortable.ghost.style.opacity = '1';
-          }
-        },
-        children: fields.map(function (item, index) {
-          return jsx(TafFormRow, {
-            field: item,
-            index: index,
-            disabled: isDisabled,
-            onRemoveChangeGroup: onRemoverow,
-            onAddChangeGroupBelow: onAddRow,
-            onAddChangeGroupAbove: function onAddChangeGroupAbove() {
-              return onAddRow(index, true);
-            },
-            onClearRow: function onClearRow() {
-              return _onClearRow(index, true);
-            },
-            isChangeGroup: true,
-            dragHandle: jsx(DragHandle, {
-              isDisabled: fields.length === 1 || isDisabled,
-              isSorting: activeDraggingIndex === index,
-              index: index
-            }),
-            isNotRequiredForAction: isNotRequiredForAction
-          }, item.id);
-        })
-      }), !isDisabled && isEditor && jsx(Grid2, {
-        container: true,
-        sx: {
-          justifyContent: 'space-between',
-          alignItems: 'center',
-          marginLeft: 1.5,
-          marginTop: 1
-        },
-        children: jsx(Grid2, {
-          children: jsx(IssuesButton, {
-            errors: errors,
-            isIssuesPaneOpen: isIssuesPaneOpen,
-            setIsIssuesPaneOpen: setIsIssuesPaneOpen
-          })
-        })
-      }), isEditor && jsx(TafFormButtons, {
-        isFormDisabled: isDisabled,
-        tafAction: tafAction,
-        canBe: tafFromBackend.canbe,
-        onTafEditModeButtonPress: onTafEditModeButtonPress,
-        onTafViewModeButtonPress: onTafViewModeButtonPress
-      }), hiddenInputFields.map(function (field) {
-        return jsx(ReactHookFormHiddenInput, {
-          name: field,
-          "data-testid": field
-        }, field);
-      })]
-    })]
-  });
-}, function (prevProps, nextProps) {
-  // prevent re-render
-  return !nextProps.isDisabled && prevProps.tafFromBackend !== nextProps.tafFromBackend &&
-  // if editor changed it should rerender
-  prevProps.tafFromBackend.editor === nextProps.tafFromBackend.editor;
-});
-
-var _excluded$2 = ["children", "value", "index"];
-var TabPanel = function TabPanel(_ref) {
-  var children = _ref.children,
-    value = _ref.value,
-    index = _ref.index,
-    other = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-  return jsx(Box, Object.assign({
-    role: "tabpanel",
-    hidden: value !== index,
-    id: "simple-tabpanel-" + index,
-    "aria-labelledby": "simple-tab-" + index,
-    "data-testid": "tab-panel-" + index
-  }, other, {
-    children: value === index && children
-  }));
-};
-
-var TafHeader = function TafHeader(_ref) {
-  var title = _ref.title,
-    _ref$sx = _ref.sx,
-    sx = _ref$sx === void 0 ? {} : _ref$sx;
-  return jsx(Typography, {
-    sx: Object.assign({
-      textAlign: 'center',
-      fontWeight: 500,
-      paddingTop: '4px',
-      textTransform: 'capitalize'
-    }, sx),
-    children: title
-  });
-};
-
-var location_indicator_mwo = "EHDB";
-var locations = {
-	EHAM: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Schiphol"
-	},
-	EHRD: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Rotterdam"
-	},
-	EHGG: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Eelde"
-	},
-	EHBK: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Maastricht"
-	},
-	EHLE: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Lelystad"
-	},
-	TNCB: {
-		validity_duration: 30,
-		activity_period: 6,
-		label: "Bonaire"
-	}
-};
-var locationOrder = [
-	"EHAM",
-	"EHRD",
-	"EHLE",
-	"EHGG",
-	"EHBK",
-	"TNCB"
-];
-var autoTAFlocations = [
-	"EHAM",
-	"EHRD",
-	"EHLE",
-	"EHGG",
-	"EHBK"
-];
-var tafConfig = {
-	location_indicator_mwo: location_indicator_mwo,
-	locations: locations,
-	locationOrder: locationOrder,
-	autoTAFlocations: autoTAFlocations
-};
-
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2022 - Finnish Meteorological Institute (FMI)
- * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
- * */
-// TODO: should be validated
-var getTafSettings = function getTafSettings() {
-  return tafConfig;
-};
-var tafSettings = getTafSettings();
-var getLocationSetting = function getLocationSetting(location, locationSettings) {
-  if (locationSettings === void 0) {
-    locationSettings = tafSettings.locations;
-  }
-  return locationSettings[location];
-};
-var sortTafsOnLocation = function sortTafsOnLocation(tafList, locationOrder) {
-  if (tafList === void 0) {
-    tafList = [];
-  }
-  if (locationOrder === void 0) {
-    locationOrder = tafSettings.locationOrder;
-  }
-  return [].concat(tafList).sort(function (_ref, _ref2) {
-    var tafA = _ref.taf;
-    var tafB = _ref2.taf;
-    return locationOrder.indexOf(tafA.location) < locationOrder.indexOf(tafB.location) ? -1 : 1;
-  });
-};
-var sortTafsOnIssueDate = function sortTafsOnIssueDate(tafList) {
-  if (tafList === void 0) {
-    tafList = [];
-  }
-  return [].concat(tafList).sort(function (_ref3, _ref4) {
-    var tafA = _ref3.taf;
-    var tafB = _ref4.taf;
-    if (tafA.issueDate < tafB.issueDate || tafA.issueDate && !tafB.issueDate) {
-      return 1;
+        break;
     }
-    return -1;
-  });
-};
-var getBaseTime = function getBaseTime(baseTime, location) {
-  var currentBaseTime = dateUtils.utc(baseTime);
-  var activityPeriod = getLocationSetting(location).activity_period;
-  var nextBaseTime = dateUtils.add(dateUtils.utc(baseTime), {
-    hours: activityPeriod
-  });
-  return {
-    currentBaseTime: currentBaseTime,
-    nextBaseTime: nextBaseTime
   };
-};
-var getTafTimeSlot = function getTafTimeSlot(baseTime, location, status) {
-  var now = dateUtils.utc();
-  var _getBaseTime = getBaseTime(baseTime, location),
-    currentBaseTime = _getBaseTime.currentBaseTime,
-    nextBaseTime = _getBaseTime.nextBaseTime;
-  if (status === 'EXPIRED') {
-    return 'EXPIRED';
-  }
-  if (currentBaseTime.getTime() < now.getTime() && nextBaseTime.getTime() > now.getTime()) {
-    return 'ACTIVE';
-  }
-  return 'UPCOMING';
-};
-var sortTafTimeSlots = function sortTafTimeSlots(tafList) {
-  var sortedListOnIssueDate = sortTafsOnIssueDate(tafList);
-  var sortedListOnLocation = sortTafsOnLocation(sortedListOnIssueDate);
-  return sortedListOnLocation.reduce(function (sortedTafList, tafFromBackend) {
-    var taf = tafFromBackend.taf;
-    var timeSlot = getTafTimeSlot(taf.baseTime, taf.location, taf.status);
-    if (timeSlot === 'EXPIRED') {
-      sortedTafList.expired.push(tafFromBackend);
-    } else if (timeSlot === 'ACTIVE') {
-      sortedTafList.current.push(tafFromBackend);
-    } else {
-      sortedTafList.upcoming.push(tafFromBackend);
+  var onRemoverow = function onRemoverow(index) {
+    void confirmDialog({
+      title: t('options-delete'),
+      description: t('confirm-delete-description'),
+      confirmLabel: t('confirm-yes')
+    }).then(function () {
+      remove(index);
+      void trigger(); // trigger all fields validation
+    });
+  };
+  // TODO: https://gitlab.com/opengeoweb/opengeoweb/-/issues/726 insert (react-hook-form) does not work well with focus (only last row will get focus), so added this dirty solution. This can be fixed in a better way in react-hook-form v7
+  var focusFirstInput = function focusFirstInput(rowIndex) {
+    var selector = rowIndex === -1 ? "[name=\"baseForecast.wind\"]" : "[name=\"changeGroups[" + rowIndex + "].probability\"]";
+    var nextRowFirstInput = document.querySelector(selector);
+    if (nextRowFirstInput) {
+      nextRowFirstInput.focus();
     }
-    return sortedTafList;
-  }, {
-    current: [],
-    upcoming: [],
-    expired: []
-  });
-};
-var muiTabA11yProps = function muiTabA11yProps(index) {
-  return {
-    id: "simple-tab-" + index,
-    'aria-controls': "simple-tabpanel-" + index
   };
-};
-var prepareTafExportValues = function prepareTafExportValues(tafToCopy, currentTaf) {
-  var _currentTaf$baseForec;
-  var convertedCopy = prepareTafValues(tafToCopy, undefined, false);
-  var baseForecast = convertedCopy.baseForecast,
-    _convertedCopy$change = convertedCopy.changeGroups,
-    changeGroups = _convertedCopy$change === void 0 ? [] : _convertedCopy$change;
-  return Object.assign({}, currentTaf, {
-    baseForecast: Object.assign({}, baseForecast, {
-      valid: currentTaf == null || (_currentTaf$baseForec = currentTaf.baseForecast) == null ? void 0 : _currentTaf$baseForec.valid
-    }),
-    changeGroups: changeGroups
-  });
-};
-var getNewTafLocationIndex = function getNewTafLocationIndex(tafLocations, previousTafLocationUUID) {
-  var newActiveIndexForDraft = tafLocations.findIndex(function (location) {
-    var _location$taf;
-    return (location == null || (_location$taf = location.taf) == null ? void 0 : _location$taf.previousId) === previousTafLocationUUID;
-  });
-  if (newActiveIndexForDraft !== -1) {
-    return newActiveIndexForDraft;
-  }
-  var newActiveIndexForPublished = tafLocations.findIndex(function (location) {
-    var _location$taf2;
-    return (location == null || (_location$taf2 = location.taf) == null ? void 0 : _location$taf2.uuid) === previousTafLocationUUID;
+  // adding rows and validation don't work well combined, with always skipping validation of fields of rows above the one the inserted row. A setTimeout prevents this issue
+  var setFocusAndValidate = function setFocusAndValidate(rowIndex) {
+    return setTimeout(function () {
+      focusFirstInput(rowIndex);
+      void trigger(); // trigger all fields validation
+    }, 0);
+  };
+  var onAddRow = function onAddRow(rowIndex, above) {
+    if (rowIndex === void 0) {
+      rowIndex = -1;
+    }
+    if (above === void 0) {
+      above = false;
+    }
+    var newRowIndex = above ? rowIndex : rowIndex + 1;
+    insert(newRowIndex, emptyChangegroup, {
+      shouldFocus: false
+    });
+    setFocusAndValidate(newRowIndex);
+  };
+  var _onClearRow = function onClearRow(rowIndex, isChangeGroup) {
+    if (rowIndex === void 0) {
+      rowIndex = -1;
+    }
+    if (isChangeGroup === void 0) {
+      isChangeGroup = false;
+    }
+    void confirmDialog({
+      title: t('options-clear'),
+      description: t('confirm-clear-description'),
+      confirmLabel: t('confirm-yes')
+    }).then(function () {
+      if (isChangeGroup) {
+        remove(rowIndex);
+        insert(rowIndex, emptyChangegroup, {
+          shouldFocus: false
+        });
+      } else {
+        var baseForecastFields = getFieldNames(false, -1);
+        setValue(baseForecastFields.wind, '');
+        setValue(baseForecastFields.visibility, '');
+        setValue(baseForecastFields.weather1, '');
+        setValue(baseForecastFields.weather2, '');
+        setValue(baseForecastFields.weather3, '');
+        setValue(baseForecastFields.cloud1, '');
+        setValue(baseForecastFields.cloud2, '');
+        setValue(baseForecastFields.cloud3, '');
+        setValue(baseForecastFields.cloud4, '');
+      }
+      setFocusAndValidate(rowIndex);
+    });
+  };
+  var _React$useState = React__default.useState(false),
+    shouldValidate = _React$useState[0],
+    setShouldValidate = _React$useState[1];
+  React__default.useEffect(function () {
+    setIsDisabled(!isEditor || isDefaultDisabled);
+    // set validate flag to validate after the values have been set
+    setShouldValidate(true);
+    // register validate method to use in parent components
+    var onValidateFormPromise = function onValidateFormPromise() {
+      return new Promise(function (resolve, reject) {
+        toggleIsDraft(true);
+        void handleSubmit(function (formData) {
+          resolve(convertTafValuesToObject(formData));
+        })().then(function (formData) {
+          if (formData === undefined) {
+            reject();
+          }
+          resolve(formData);
+        });
+      });
+    };
+    if (registerValidateForm) {
+      registerValidateForm(onValidateFormPromise);
+    }
+    // set default taf action
+    if (setTafAction) {
+      setTafAction(fromStatusToAction(originalTaf.status));
+    }
+    return function () {
+      resetFormValues({});
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  React__default.useEffect(function () {
+    var newValues = prepareTafValues(originalTaf, undefined, !isDefaultDisabled);
+    // set new form values when taf values changed
+    resetFormValues(newValues);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [originalTaf]);
+  React__default.useEffect(function () {
+    // update disabled state when editor changed
+    setIsDisabled(!isEditor || isDefaultDisabled);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor]);
+  React__default.useEffect(function () {
+    if (shouldValidate && !isDisabled) {
+      // trigger validation on all changegroup validity times after form is enabled since they could be outside the new validity period
+      var _originalTaf$changeGr = originalTaf.changeGroups,
+        changeGroups = _originalTaf$changeGr === void 0 ? [] : _originalTaf$changeGr;
+      var validFields = changeGroups.map(function (_field, index) {
+        return "changeGroups[" + index + "].valid";
+      });
+      void trigger(validFields);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [shouldValidate, isDisabled]);
+  return jsxs(Fragment, {
+    children: [jsxs(Box, {
+      sx: {
+        display: 'flex',
+        flexDirection: 'row',
+        alignItems: 'center',
+        position: 'absolute',
+        top: {
+          xs: '34px',
+          sm: '-3px'
+        },
+        right: {
+          xs: 'calc(50% -  70px)',
+          sm: '8px'
+        }
+      },
+      children: [jsx(SwitchButton, {
+        checked: isEditor,
+        onChange: onSwitchMode
+      }), jsx(Box, {
+        sx: {
+          width: '16px',
+          marginLeft: 1
+        },
+        children: editor && jsx(TafAvatar, {
+          editor: editor
+        })
+      })]
+    }), jsxs("form", {
+      "data-testid": "taf-form",
+      onSubmit: handleSubmit(onSubmit),
+      ref: formRef,
+      children: [jsx(TafFormRow, {
+        disabled: isDisabled,
+        onAddChangeGroupBelow: onAddRow,
+        onClearRow: _onClearRow,
+        isNotRequiredForAction: isNotRequiredForAction
+      }), jsx(ReactSortable, {
+        tag: "div",
+        list: fields,
+        setList: noop,
+        animation: 200,
+        onSort: onChangeOrder,
+        handle: ".handle",
+        direction: "vertical",
+        // hover props
+        forceFallback: false,
+        onStart: function onStart(event) {
+          onStartDrag(event);
+          if (Sortable.ghost) {
+            Sortable.ghost.style.opacity = '1';
+          }
+        },
+        children: fields.map(function (item, index) {
+          return jsx(TafFormRow, {
+            field: item,
+            index: index,
+            disabled: isDisabled,
+            onRemoveChangeGroup: onRemoverow,
+            onAddChangeGroupBelow: onAddRow,
+            onAddChangeGroupAbove: function onAddChangeGroupAbove() {
+              return onAddRow(index, true);
+            },
+            onClearRow: function onClearRow() {
+              return _onClearRow(index, true);
+            },
+            isChangeGroup: true,
+            dragHandle: jsx(DragHandle, {
+              isDisabled: fields.length === 1 || isDisabled,
+              isSorting: activeDraggingIndex === index,
+              index: index
+            }),
+            isNotRequiredForAction: isNotRequiredForAction
+          }, item.id);
+        })
+      }), !isDisabled && isEditor && jsx(Grid2, {
+        container: true,
+        sx: {
+          justifyContent: 'space-between',
+          alignItems: 'center',
+          marginLeft: 1.5,
+          marginTop: 1
+        },
+        children: jsx(Grid2, {
+          children: jsx(IssuesButton, {
+            errors: errors,
+            isIssuesPaneOpen: isIssuesPaneOpen,
+            setIsIssuesPaneOpen: setIsIssuesPaneOpen
+          })
+        })
+      }), isEditor && jsx(TafFormButtons, {
+        isFormDisabled: isDisabled,
+        tafAction: tafAction,
+        canBe: tafFromBackend.canbe,
+        onTafEditModeButtonPress: onTafEditModeButtonPress,
+        onTafViewModeButtonPress: onTafViewModeButtonPress
+      }), hiddenInputFields.map(function (field) {
+        return jsx(ReactHookFormHiddenInput, {
+          name: field,
+          "data-testid": field
+        }, field);
+      })]
+    })]
   });
-  if (newActiveIndexForPublished !== -1) {
-    return newActiveIndexForPublished;
-  }
-  return 0;
+}, function (prevProps, nextProps) {
+  // prevent re-render
+  return !nextProps.isDisabled && prevProps.tafFromBackend !== nextProps.tafFromBackend &&
+  // if editor changed it should rerender
+  prevProps.tafFromBackend.editor === nextProps.tafFromBackend.editor;
+});
+
+var _excluded$2 = ["children", "value", "index"];
+var TabPanel = function TabPanel(_ref) {
+  var children = _ref.children,
+    value = _ref.value,
+    index = _ref.index,
+    other = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+  return jsx(Box, Object.assign({
+    role: "tabpanel",
+    hidden: value !== index,
+    id: "simple-tabpanel-" + index,
+    "aria-labelledby": "simple-tab-" + index,
+    "data-testid": "tab-panel-" + index
+  }, other, {
+    children: value === index && children
+  }));
 };
-var getPreviousTaf = function getPreviousTaf(tafList, currentTaf) {
-  var previousId = currentTaf.taf.previousId;
-  if (!previousId) {
-    return null;
-  }
-  var previousTaf = tafList.find(function (taf) {
-    return taf.taf.uuid === previousId;
+
+var TafHeader = function TafHeader(_ref) {
+  var title = _ref.title,
+    _ref$sx = _ref.sx,
+    sx = _ref$sx === void 0 ? {} : _ref$sx;
+  return jsx(Typography, {
+    sx: Object.assign({
+      textAlign: 'center',
+      fontWeight: 500,
+      paddingTop: '4px',
+      textTransform: 'capitalize'
+    }, sx),
+    children: title
   });
-  return previousTaf ? previousTaf.taf : null;
-};
-var getAutoTafLocations = function getAutoTafLocations(autoTAFlocations) {
-  if (autoTAFlocations === void 0) {
-    autoTAFlocations = tafSettings.autoTAFlocations;
-  }
-  return autoTAFlocations || null;
-};
-var scrollToPosition = function scrollToPosition(scrollRef, activeLocation) {
-  if (!scrollRef.current) {
-    return;
-  }
-  var containerTop = scrollRef.current.getBoundingClientRect().top;
-  var firstLocation = scrollRef.current.querySelector("[data-location=\"" + activeLocation + "\"]");
-  var paddingTop = parseInt(getComputedStyle(scrollRef.current).paddingTop, 10);
-  var firstLocationTop = firstLocation == null ? void 0 : firstLocation.getBoundingClientRect().top;
-  var newScrollPosition = firstLocationTop - containerTop + scrollRef.current.scrollTop - paddingTop;
-  scrollRef.current.scrollTo(newScrollPosition, newScrollPosition);
 };
 
 var IconWithTooltip = function IconWithTooltip(_ref) {
@@ -5357,10 +5545,8 @@ var TacContainer = function TacContainer(_ref2) {
     isFormDisabled = _ref2$isFormDisabled === void 0 ? false : _ref2$isFormDisabled;
   var _useTafTranslation = useTafTranslation(),
     t = _useTafTranslation.t;
-  var _useApiContext = useApiContext(),
-    api = _useApiContext.api;
   var dispatch = useDispatch();
-  var _useTACGenerator = useTACGenerator(taf, api.getTAC, true),
+  var _useTACGenerator = useTACGenerator(taf),
     TAC = _useTACGenerator[0],
     retrieveTAC = _useTACGenerator[1];
   var status = taf.status,
@@ -5411,7 +5597,8 @@ var TacContainer = function TacContainer(_ref2) {
     if (isActive) {
       retrieveTAC(taf);
     }
-  }, [taf, isActive, retrieveTAC]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isActive]);
   return jsxs(Box, {
     sx: {
       marginBottom: '20px'
@@ -5837,9 +6024,6 @@ var TacOverviewMobile = function TacOverviewMobile(_ref) {
   });
 };
 
-var formatBaseTime = function formatBaseTime(time) {
-  return dateUtils.dateToString(time, DATE_FORMAT_BASE_TIME);
-};
 var TopTabs = function TopTabs(_ref) {
   var timeSlot = _ref.timeSlot,
     _ref$onChangeTimeSlot = _ref.onChangeTimeSlot,
@@ -5998,159 +6182,73 @@ var fromActionToStatus = function fromActionToStatus(tafAction) {
       return 'NEW';
   }
 };
-var isWarning = function isWarning(error) {
-  return (error == null ? void 0 : error.type) === 'WARNING';
-};
-var parseErrorMessage = function parseErrorMessage(error, params, t) {
-  var message = getErrorMessage$1(error);
-  var warningMessage = getWarningMessage(error);
-  if (warningMessage) {
-    return {
-      type: 'WARNING',
-      title: warningMessage
-    };
-  }
-  return params.changeStatusTo === 'CANCELLED' ? {
-    type: 'CANCELLED',
-    title: t('error-cancel'),
-    message: message
-  } : {
-    type: 'SERVER',
-    title: t('error-save'),
-    message: message
-  };
-};
-var usePostTafRequest = function usePostTafRequest(request) {
-  var _useTafTranslation = useTafTranslation(),
-    t = _useTafTranslation.t;
-  var _useIsMounted = useIsMounted(),
-    isMounted = _useIsMounted.isMounted;
-  var _React$useState = React__default.useState(false),
-    isLoading = _React$useState[0],
-    setLoading = _React$useState[1];
-  var _React$useState2 = React__default.useState(),
-    error = _React$useState2[0],
-    setError = _React$useState2[1];
-  var doRequest = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
-      var newError;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            setLoading(true);
-            setError(null);
-            _context.prev = 2;
-            _context.next = 5;
-            return request(params);
-          case 5:
-            if (isMounted.current) {
-              _context.next = 7;
-              break;
-            }
-            return _context.abrupt("return");
-          case 7:
-            setLoading(false);
-            setError(null);
-            _context.next = 19;
-            break;
-          case 11:
-            _context.prev = 11;
-            _context.t0 = _context["catch"](2);
-            if (isMounted.current) {
-              _context.next = 15;
-              break;
-            }
-            return _context.abrupt("return");
-          case 15:
-            newError = parseErrorMessage(_context.t0, params, t);
-            setLoading(false);
-            setError(newError);
-            // eslint-disable-next-line @typescript-eslint/no-throw-literal
-            throw newError;
-          case 19:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee, null, [[2, 11]]);
-    }));
-    return function doRequest(_x) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-  return {
-    isLoading: isLoading,
-    error: error,
-    setError: setError,
-    doRequest: doRequest
-  };
-};
-var TafPanel = function TafPanel(_ref2) {
-  var tafFromBackend = _ref2.tafFromBackend,
-    activeTafIndex = _ref2.activeTafIndex,
-    index = _ref2.index,
-    _ref2$isLoading = _ref2.isLoading,
-    isLoading = _ref2$isLoading === void 0 ? false : _ref2$isLoading,
-    _ref2$postTaf = _ref2.postTaf,
-    postTaf = _ref2$postTaf === void 0 ? function () {
+var TafPanel = function TafPanel(_ref) {
+  var tafFromBackend = _ref.tafFromBackend,
+    activeTafIndex = _ref.activeTafIndex,
+    index = _ref.index,
+    _ref$isLoading = _ref.isLoading,
+    isLoading = _ref$isLoading === void 0 ? false : _ref$isLoading,
+    _ref$postTaf = _ref.postTaf,
+    postTaf = _ref$postTaf === void 0 ? function () {
       return null;
-    } : _ref2$postTaf,
-    _ref2$patchTaf = _ref2.patchTaf,
-    patchTaf = _ref2$patchTaf === void 0 ? function () {
+    } : _ref$postTaf,
+    _ref$patchTaf = _ref.patchTaf,
+    patchTaf = _ref$patchTaf === void 0 ? function () {
       return null;
-    } : _ref2$patchTaf,
-    _ref2$isIssuesPaneOpe = _ref2.isIssuesPaneOpen,
-    isIssuesPaneOpen = _ref2$isIssuesPaneOpe === void 0 ? false : _ref2$isIssuesPaneOpe,
-    _ref2$setIsIssuesPane = _ref2.setIsIssuesPaneOpen,
-    setIsIssuesPaneOpen = _ref2$setIsIssuesPane === void 0 ? function () {
+    } : _ref$patchTaf,
+    _ref$isIssuesPaneOpen = _ref.isIssuesPaneOpen,
+    isIssuesPaneOpen = _ref$isIssuesPaneOpen === void 0 ? false : _ref$isIssuesPaneOpen,
+    _ref$setIsIssuesPaneO = _ref.setIsIssuesPaneOpen,
+    setIsIssuesPaneOpen = _ref$setIsIssuesPaneO === void 0 ? function () {
       return null;
-    } : _ref2$setIsIssuesPane,
-    _ref2$isFormDisabled = _ref2.isFormDisabled,
-    isFormDisabled = _ref2$isFormDisabled === void 0 ? false : _ref2$isFormDisabled,
-    _ref2$setIsFormDisabl = _ref2.setIsFormDisabled,
-    setIsFormDisabled = _ref2$setIsFormDisabl === void 0 ? function () {
+    } : _ref$setIsIssuesPaneO,
+    _ref$isFormDisabled = _ref.isFormDisabled,
+    isFormDisabled = _ref$isFormDisabled === void 0 ? false : _ref$isFormDisabled,
+    _ref$setIsFormDisable = _ref.setIsFormDisabled,
+    setIsFormDisabled = _ref$setIsFormDisable === void 0 ? function () {
       return null;
-    } : _ref2$setIsFormDisabl,
-    error = _ref2.error,
-    _ref2$previousTaf = _ref2.previousTaf,
-    previousTaf = _ref2$previousTaf === void 0 ? null : _ref2$previousTaf,
-    tafAction = _ref2.tafAction;
-  var _useTafTranslation2 = useTafTranslation(),
-    t = _useTafTranslation2.t;
+    } : _ref$setIsFormDisable,
+    error = _ref.error,
+    _ref$previousTaf = _ref.previousTaf,
+    previousTaf = _ref$previousTaf === void 0 ? null : _ref$previousTaf,
+    tafAction = _ref.tafAction;
+  var _useTafTranslation = useTafTranslation(),
+    t = _useTafTranslation.t;
   var severity = isWarning(error) ? 'warning' : 'error';
   var onTafAction = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(action, taf) {
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(action, taf) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
           case 0:
-            _context2.prev = 0;
-            _context2.t0 = action;
-            _context2.next = _context2.t0 === 'DRAFT' ? 4 : _context2.t0 === 'DRAFT_AMEND' ? 4 : _context2.t0 === 'DRAFT_CORRECT' ? 4 : _context2.t0 === 'PUBLISH' ? 4 : _context2.t0 === 'AMEND' ? 4 : _context2.t0 === 'CANCEL' ? 4 : _context2.t0 === 'CORRECT' ? 4 : 7;
+            _context.prev = 0;
+            _context.t0 = action;
+            _context.next = _context.t0 === 'DRAFT' ? 4 : _context.t0 === 'DRAFT_AMEND' ? 4 : _context.t0 === 'DRAFT_CORRECT' ? 4 : _context.t0 === 'PUBLISH' ? 4 : _context.t0 === 'AMEND' ? 4 : _context.t0 === 'CANCEL' ? 4 : _context.t0 === 'CORRECT' ? 4 : 7;
             break;
           case 4:
-            _context2.next = 6;
+            _context.next = 6;
             return postTaf({
               taf: taf,
               changeStatusTo: fromActionToStatus(action)
             });
           case 6:
-            return _context2.abrupt("return", true);
+            return _context.abrupt("return", true);
           case 7:
-            return _context2.abrupt("return", false);
+            return _context.abrupt("return", false);
           case 8:
-            _context2.next = 13;
+            _context.next = 13;
             break;
           case 10:
-            _context2.prev = 10;
-            _context2.t1 = _context2["catch"](0);
-            return _context2.abrupt("return", false);
+            _context.prev = 10;
+            _context.t1 = _context["catch"](0);
+            return _context.abrupt("return", false);
           case 13:
           case "end":
-            return _context2.stop();
+            return _context.stop();
         }
-      }, _callee2, null, [[0, 10]]);
+      }, _callee, null, [[0, 10]]);
     }));
-    return function onTafAction(_x2, _x3) {
-      return _ref3.apply(this, arguments);
+    return function onTafAction(_x, _x2) {
+      return _ref2.apply(this, arguments);
     };
   }();
   return jsxs(TabPanel, {
@@ -6176,73 +6274,36 @@ var TafPanel = function TafPanel(_ref2) {
       dataTestId: "taf-error",
       shouldClose: true
     }), jsx(Box, {
-      sx: {
-        marginTop: {
-          xs: '44px',
-          sm: '10px'
-        },
-        padding: 1
-      },
-      children: jsx(TafForm, {
-        tafFromBackend: tafFromBackend,
-        onFormAction: onTafAction,
-        isIssuesPaneOpen: isIssuesPaneOpen,
-        setIsIssuesPaneOpen: setIsIssuesPaneOpen,
-        isDisabled: isFormDisabled,
-        setIsDisabled: setIsFormDisabled,
-        onSwitchEditor: patchTaf,
-        previousTaf: previousTaf
-      })
-    })]
-  });
-};
-
-var IssuesPaneWrapper = function IssuesPaneWrapper(props) {
-  var _useFormContext = useFormContext(),
-    errors = _useFormContext.formState.errors;
-  var errorList = filterDuplicateErrors(getErrors(errors));
-  return jsx(IssuesPane, Object.assign({
-    errorList: errorList
-  }, props));
-};
-
-var getTafMessageContent = function getTafMessageContent(_ref) {
-  var location = _ref.location,
-    validDateStart = _ref.validDateStart,
-    messageType = _ref.messageType;
-  var formattedDate = formatBaseTime(dateUtils.utc(validDateStart));
-  return {
-    location: location,
-    formattedDate: formattedDate,
-    messageType: messageType
-  };
-};
-var getSnackbarMessage = function getSnackbarMessage(tafFromFrontEnd, isAutoSaved, t) {
-  var changeStatusTo = tafFromFrontEnd.changeStatusTo,
-    taf = tafFromFrontEnd.taf;
-  if (isAutoSaved) {
-    return t('snackbar-auto-save');
-  }
-  var content = getTafMessageContent(taf);
-  switch (changeStatusTo) {
-    case 'DRAFT':
-      return t('snackbar-draft');
-    case 'DRAFT_AMENDED':
-      return t('snackbar-draft-amend');
-    case 'DRAFT_CORRECTED':
-      return t('snackbar-draft-correct');
-    case 'PUBLISHED':
-      return t('snackbar-publish', content);
-    case 'CANCELLED':
-      return t('snackbar-cancel', content);
-    case 'CORRECTED':
-      return t('snackbar-correct', content);
-    case 'AMENDED':
-      return t('snackbar-amend', content);
-    default:
-      return t('snackbar-save', content);
-  }
+      sx: {
+        marginTop: {
+          xs: '44px',
+          sm: '10px'
+        },
+        padding: 1
+      },
+      children: jsx(TafForm, {
+        tafFromBackend: tafFromBackend,
+        onFormAction: onTafAction,
+        isIssuesPaneOpen: isIssuesPaneOpen,
+        setIsIssuesPaneOpen: setIsIssuesPaneOpen,
+        isDisabled: isFormDisabled,
+        setIsDisabled: setIsFormDisabled,
+        onSwitchEditor: patchTaf,
+        previousTaf: previousTaf
+      })
+    })]
+  });
+};
+
+var IssuesPaneWrapper = function IssuesPaneWrapper(props) {
+  var _useFormContext = useFormContext(),
+    errors = _useFormContext.formState.errors;
+  var errorList = filterDuplicateErrors(getErrors(errors));
+  return jsx(IssuesPane, Object.assign({
+    errorList: errorList
+  }, props));
 };
+
 var filterAutoTafs = function filterAutoTafs(tafList) {
   return tafList.reduce(function (tList, tafFromBackend) {
     var _Object$assign;
@@ -6254,25 +6315,22 @@ var filterAutoTafs = function filterAutoTafs(tafList) {
     autoTafList: []
   });
 };
-var TafLayout = function TafLayout(_ref2) {
-  var completTafList = _ref2.tafList,
-    _ref2$onUpdateTaf = _ref2.onUpdateTaf,
-    onUpdateTaf = _ref2$onUpdateTaf === void 0 ? function () {
+var TafLayout = function TafLayout(_ref) {
+  var completeTafList = _ref.tafList,
+    _ref$onUpdateTaf = _ref.onUpdateTaf,
+    onUpdateTaf = _ref$onUpdateTaf === void 0 ? function () {
       return null;
-    } : _ref2$onUpdateTaf,
-    lastUpdateTime = _ref2.lastUpdateTime,
-    _ref2$isAutoTafEnable = _ref2.isAutoTafEnabled,
-    isAutoTafEnabled = _ref2$isAutoTafEnable === void 0 ? false : _ref2$isAutoTafEnable;
+    } : _ref$onUpdateTaf,
+    lastUpdateTime = _ref.lastUpdateTime,
+    _ref$isAutoTafEnabled = _ref.isAutoTafEnabled,
+    isAutoTafEnabled = _ref$isAutoTafEnabled === void 0 ? false : _ref$isAutoTafEnabled;
   var _React$useMemo = React__default.useMemo(function () {
-      return filterAutoTafs(completTafList);
-    }, [completTafList]),
+      return filterAutoTafs(completeTafList);
+    }, [completeTafList]),
     tafList = _React$useMemo.tafList,
     autoTafList = _React$useMemo.autoTafList;
   var _useTafTranslation = useTafTranslation(),
     t = _useTafTranslation.t;
-  var _useApiContext = useApiContext(),
-    api = _useApiContext.api;
-  var dispatch = useDispatch();
   var confirmDialog = useConfirmationDialog();
   var _useIssuesPane = useIssuesPane(),
     isIssuesPaneOpen = _useIssuesPane.isIssuesPaneOpen,
@@ -6280,13 +6338,11 @@ var TafLayout = function TafLayout(_ref2) {
     onCloseIssuesPane = _useIssuesPane.onCloseIssuesPane,
     startPosition = _useIssuesPane.startPosition,
     onUserHasDragged = _useIssuesPane.onUserHasDragged;
-  var _usePostTafRequest = usePostTafRequest(api.postTaf),
-    isLoading = _usePostTafRequest.isLoading,
-    postTafRequest = _usePostTafRequest.doRequest,
-    postError = _usePostTafRequest.error;
-  var _usePostTafRequest2 = usePostTafRequest(api.patchTaf),
-    patchTafRequest = _usePostTafRequest2.doRequest,
-    patchError = _usePostTafRequest2.error;
+  var _usePostTaf = usePostTaf(),
+    isPostTafPending = _usePostTaf.isPending,
+    postTafRequest = _usePostTaf.mutateAsync;
+  var _usePatchTaf = usePatchTaf(),
+    patchTafRequest = _usePatchTaf.mutateAsync;
   var _useTafModuleContext = useTafModuleContext(),
     onValidateForm = _useTafModuleContext.onValidateForm,
     tafAction = _useTafModuleContext.tafAction;
@@ -6310,75 +6366,58 @@ var TafLayout = function TafLayout(_ref2) {
   var _React$useState5 = React__default.useState(false),
     isFormDisabled = _React$useState5[0],
     setIsFormDisabled = _React$useState5[1];
-  var _React$useState6 = React__default.useState(),
+  var _React$useState6 = React__default.useState(null),
     error = _React$useState6[0],
     setError = _React$useState6[1];
-  var showSnackbar = React__default.useCallback(function (message) {
-    dispatch(snackbarActions.openSnackbar({
-      type: snackbarTypes.SnackbarMessageType.VERBATIM_MESSAGE,
-      message: message
-    }));
-  }, [dispatch]);
   var postTaf = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(data, isAutoSaved) {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(data, isAutoSaved) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             if (isAutoSaved === void 0) {
               isAutoSaved = false;
             }
-            _context.prev = 1;
-            setError(null);
-            _context.next = 5;
-            return postTafRequest(data);
-          case 5:
-            showSnackbar(getSnackbarMessage(data, isAutoSaved, t));
-            // callback
-            void onUpdateTaf();
-            _context.next = 13;
-            break;
-          case 9:
-            _context.prev = 9;
-            _context.t0 = _context["catch"](1);
-            if (isWarning(_context.t0)) {
-              void onUpdateTaf();
-            }
-            throw _context.t0;
-          case 13:
+            _context.next = 3;
+            return postTafRequest({
+              tafData: data,
+              isAutoSaved: isAutoSaved,
+              setError: setError
+            });
+          case 3:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[1, 9]]);
+      }, _callee);
     }));
     return function postTaf(_x, _x2) {
-      return _ref3.apply(this, arguments);
+      return _ref2.apply(this, arguments);
     };
   }();
   var patchTaf = /*#__PURE__*/function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(data) {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(data) {
       return _regeneratorRuntime().wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
             _context2.prev = 0;
-            setError(null);
-            _context2.next = 4;
-            return patchTafRequest(data);
-          case 4:
-            // callback
-            void onUpdateTaf();
+            _context2.next = 3;
+            return patchTafRequest({
+              tafData: data,
+              setError: setError
+            });
+          case 3:
             return _context2.abrupt("return", true);
-          case 8:
-            _context2.prev = 8;
+          case 6:
+            _context2.prev = 6;
             _context2.t0 = _context2["catch"](0);
             return _context2.abrupt("return", false);
-          case 11:
+          case 9:
           case "end":
             return _context2.stop();
         }
-      }, _callee2, null, [[0, 8]]);
+      }, _callee2, null, [[0, 6]]);
     }));
     return function patchTaf(_x3) {
-      return _ref4.apply(this, arguments);
+      return _ref3.apply(this, arguments);
     };
   }();
   var CONFIRM_DIALOG_OPTIONS = {
@@ -6458,8 +6497,7 @@ var TafLayout = function TafLayout(_ref2) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [tafList, setLocations]);
   React__default.useEffect(function () {
-    setError(postError);
-    var cancelErrorTimeout = postError && postError.type === 'CANCELLED' ? setTimeout(function () {
+    var cancelErrorTimeout = error && error.type === 'CANCELLED' ? setTimeout(function () {
       setError(null);
     }, 10000) : null;
     return function () {
@@ -6467,10 +6505,7 @@ var TafLayout = function TafLayout(_ref2) {
         clearTimeout(cancelErrorTimeout);
       }
     };
-  }, [postError]);
-  React__default.useEffect(function () {
-    setError(patchError);
-  }, [patchError]);
+  }, [error]);
   if (!tafList || !tafList.length) {
     return null;
   }
@@ -6581,7 +6616,7 @@ var TafLayout = function TafLayout(_ref2) {
                     setIsFormDisabled: setIsFormDisabled,
                     postTaf: postTaf,
                     patchTaf: patchTaf,
-                    isLoading: isLoading,
+                    isLoading: isPostTafPending,
                     error: error,
                     previousTaf: getPreviousTaf(tafList, tafFromBackend),
                     tafAction: tafAction
@@ -6666,7 +6701,7 @@ var TafModule = function TafModule(_ref) {
   var _React$useState = React.useState(null),
     errorMessage = _React$useState[0],
     setErrorMessage = _React$useState[1];
-  var _useAuthenticationCon = useAuthenticationContext(),
+  var _useAuthenticationCon = useAuthenticationContext$1(),
     isLoggedIn = _useAuthenticationCon.isLoggedIn;
   var ERROR_AUTH = t('error-auth');
   var ERROR_AUTH_MESSAGE = t('error-auth-message');
@@ -6752,45 +6787,72 @@ var Wrapper = function Wrapper(_ref3) {
   }));
 };
 
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2022 - Finnish Meteorological Institute (FMI)
- * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
- * */
-var getApiRoutes$1 = function getApiRoutes(axiosInstance) {
-  return {
-    postTaf: function postTaf(formData) {
-      return axiosInstance.post('/taf', Object.assign({}, formData));
-    },
-    getTAC: function getTAC(tafData, getJSON, signal) {
-      return axiosInstance.post('/taf2tac', tafData, Object.assign({}, signal ? {
-        signal: signal
-      } : {}, {
-        headers: {
-          Accept: getJSON ? 'application/json' : 'text/plain'
-        }
-      }));
+var tafScreenPreset = {
+  id: 'screenConfigTaf',
+  title: 'TAF',
+  views: {
+    byId: {
+      taf: {
+        title: 'TAF',
+        componentType: 'TafModule',
+        initialProps: {}
+      }
     },
-    patchTaf: function patchTaf(formData) {
-      return axiosInstance.patch('/taf?force=true', Object.assign({}, formData));
-    }
-  };
+    allIds: ['taf']
+  },
+  syncGroups: [],
+  mosaicNode: 'taf'
+};
+var TafApiWrapper = function TafApiWrapper(_ref) {
+  var config = _ref.config,
+    onPreventCloseView = _ref.onPreventCloseView,
+    initialProps = _ref.initialProps;
+  return config ? jsx(ErrorBoundary, {
+    children: jsx(Wrapper, {
+      onPreventCloseView: onPreventCloseView,
+      isAutoTafEnabled: initialProps == null ? void 0 : initialProps.isAutoTafEnabled
+    })
+  }) : null;
 };
-var createApi$1 = function createApi(props) {
-  var axiosInstance = createApiInstance(props);
-  return getApiRoutes$1(axiosInstance);
+var componentsLookUp = function componentsLookUp(payload, _ref2,
+// TODO: find a good way to type this module without the apps complaining
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ConnectedModuleWrapper) {
+  var config = _ref2.config,
+    auth = _ref2.auth,
+    onSetAuth = _ref2.onSetAuth;
+  if (ConnectedModuleWrapper === void 0) {
+    ConnectedModuleWrapper = null;
+  }
+  var componentType = payload.componentType,
+    initialProps = payload.initialProps;
+  switch (componentType) {
+    case 'TafModule':
+      if (ConnectedModuleWrapper) {
+        return jsx(ConnectedModuleWrapper, {
+          component: function component(props) {
+            return jsx(TafApiWrapper, Object.assign({}, props, {
+              initialProps: initialProps
+            }));
+          },
+          payload: payload,
+          "data-testid": "tafmodule",
+          config: config,
+          auth: auth,
+          onSetAuth: onSetAuth
+        });
+      }
+      return jsx(TafApiWrapper, {
+        "data-testid": "tafmodule",
+        config: config,
+        auth: auth,
+        onSetAuth: onSetAuth,
+        initialProps: initialProps
+      });
+    default:
+      return null;
+  }
 };
 
 // Used to mimic an authenticated user
@@ -7970,24 +8032,13 @@ var fakeAmendmentTaf = {
   })
 });
 
-/* *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2021 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
- * Copyright 2021 - Finnish Meteorological Institute (FMI)
- * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
- * */
-var fakeTafTac = 'TAF EHAM 0812/0918 20020G35KT 0500 SN BKN040\nBECMG 0814/0816 0700 BKN001=';
+var fakeUpdatedTafList = [].concat(fakeTafList);
+var setFakeUpdatedList = function setFakeUpdatedList(newList) {
+  fakeUpdatedTafList = newList;
+};
+var getFakeUpdatedList = function getFakeUpdatedList() {
+  return fakeUpdatedTafList;
+};
 var fakeTafTacJson = {
   tac: [[{
     text: 'TAF'
@@ -8020,135 +8071,67 @@ var fakeTafTacJson = {
     text: '='
   }]]
 };
-var fakeUpdatedTafList = [].concat(fakeTafList);
-var setFakeUpdatedList = function setFakeUpdatedList(newList) {
-  fakeUpdatedTafList = newList;
-};
-var getFakeUpdatedList = function getFakeUpdatedList() {
-  return fakeUpdatedTafList;
-};
-var getApiRoutes = function getApiRoutes(axiosInstance) {
-  return {
-    postTaf: function postTaf(_postTaf) {
-      // eslint-disable-next-line no-console
-      console.log("The new status of the taf will be " + _postTaf.changeStatusTo);
-      // eslint-disable-next-line no-console
-      console.log('form has been posted with following values:', _postTaf.taf);
-      return axiosInstance.post('/taf', _postTaf);
-    },
-    getTAC: function getTAC(taf, getJSON, signal) {
-      return axiosInstance.post('/taf2tac', taf, Object.assign({}, signal ? {
-        signal: signal
-      } : {}, {
-        headers: {
-          Accept: getJSON ? 'application/json' : 'text/plain'
-        }
-      })).then(function () {
-        return {
-          data: getJSON ? fakeTafTacJson : fakeTafTac
-        };
-      });
-    },
-    patchTaf: function patchTaf(_patchTaf) {
-      var updatedList = getFakeUpdatedList().map(function (tafFromBackend) {
-        if (tafFromBackend.taf.uuid === _patchTaf.taf.uuid) {
-          return Object.assign({}, tafFromBackend, {
-            editor: _patchTaf.editor
-          });
-        }
-        return tafFromBackend;
-      });
-      setFakeUpdatedList(updatedList);
-      // eslint-disable-next-line no-console
-      console.log("The new editor of the taf will be " + (_patchTaf.editor || 'empty'));
-      return axiosInstance.patch('/taf', _patchTaf);
+var tafEndPoints = [http.get(/^.*\/taflist$/, function () {
+  return HttpResponse.json(getFakeUpdatedList());
+}), http.post(/^.*\/taf$/, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+  return _regeneratorRuntime().wrap(function _callee$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        _context.next = 2;
+        return delay();
+      case 2:
+        return _context.abrupt("return", HttpResponse.json(null));
+      case 3:
+      case "end":
+        return _context.stop();
     }
-  };
-};
-var createApi = function createApi() {
-  var instance = createFakeApiInstance();
-  return getApiRoutes(instance);
-};
-
-var tafScreenPreset = {
-  id: 'screenConfigTaf',
-  title: 'TAF',
-  views: {
-    byId: {
-      taf: {
-        title: 'TAF',
-        componentType: 'TafModule',
-        initialProps: {}
-      }
-    },
-    allIds: ['taf']
-  },
-  syncGroups: [],
-  mosaicNode: 'taf'
-};
-var TafApiWrapper = function TafApiWrapper(_ref) {
-  var config = _ref.config,
-    auth = _ref.auth,
-    onSetAuth = _ref.onSetAuth,
-    onPreventCloseView = _ref.onPreventCloseView,
-    initialProps = _ref.initialProps;
-  return config ? jsx(ApiProvider, {
-    config: {
-      baseURL: config.baseURL,
-      appURL: config.baseURL,
-      authTokenURL: config.authTokenURL,
-      authClientId: config.authClientId
-    },
-    auth: auth,
-    onSetAuth: onSetAuth,
-    createApi: createApi$1,
-    children: jsx(ErrorBoundary, {
-      children: jsx(Wrapper, {
-        onPreventCloseView: onPreventCloseView,
-        isAutoTafEnabled: initialProps == null ? void 0 : initialProps.isAutoTafEnabled
-      })
-    })
-  }) : null;
-};
-var componentsLookUp = function componentsLookUp(payload, _ref2,
-// TODO: find a good way to type this module without the apps complaining
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ConnectedModuleWrapper) {
-  var config = _ref2.config,
-    auth = _ref2.auth,
-    onSetAuth = _ref2.onSetAuth;
-  if (ConnectedModuleWrapper === void 0) {
-    ConnectedModuleWrapper = null;
-  }
-  var componentType = payload.componentType,
-    initialProps = payload.initialProps;
-  switch (componentType) {
-    case 'TafModule':
-      if (ConnectedModuleWrapper) {
-        return jsx(ConnectedModuleWrapper, {
-          component: function component(props) {
-            return jsx(TafApiWrapper, Object.assign({}, props, {
-              initialProps: initialProps
-            }));
-          },
-          payload: payload,
-          "data-testid": "tafmodule",
-          config: config,
-          auth: auth,
-          onSetAuth: onSetAuth
-        });
+  }, _callee);
+}))), http.patch(/^.*\/taf$/, /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref2) {
+    var request, patchTaf, updatedList;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          request = _ref2.request;
+          _context2.next = 3;
+          return request.json();
+        case 3:
+          patchTaf = _context2.sent;
+          updatedList = getFakeUpdatedList().map(function (tafFromBackend) {
+            if (tafFromBackend.taf.uuid === patchTaf.taf.uuid) {
+              return Object.assign({}, tafFromBackend, {
+                editor: patchTaf.editor
+              });
+            }
+            return tafFromBackend;
+          });
+          setFakeUpdatedList(updatedList);
+          _context2.next = 8;
+          return delay();
+        case 8:
+          return _context2.abrupt("return", HttpResponse.json(null));
+        case 9:
+        case "end":
+          return _context2.stop();
       }
-      return jsx(TafApiWrapper, {
-        "data-testid": "tafmodule",
-        config: config,
-        auth: auth,
-        onSetAuth: onSetAuth,
-        initialProps: initialProps
-      });
-    default:
-      return null;
-  }
-};
+    }, _callee2);
+  }));
+  return function (_x) {
+    return _ref3.apply(this, arguments);
+  };
+}()), http.post(/^.*\/taf2tac$/, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+  return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+    while (1) switch (_context3.prev = _context3.next) {
+      case 0:
+        _context3.next = 2;
+        return delay();
+      case 2:
+        return _context3.abrupt("return", HttpResponse.json(fakeTafTacJson));
+      case 3:
+      case "end":
+        return _context3.stop();
+    }
+  }, _callee3);
+})))];
 
-export { TAF_NAMESPACE, TafApiWrapper, TafForm, Wrapper as TafModule, componentsLookUp, createApi$1 as createApi, createApi as createFakeApi, tafScreenPreset, tafTranslations };
+export { TAF_NAMESPACE, TafApiWrapper, TafForm, Wrapper as TafModule, componentsLookUp, tafEndPoints, tafScreenPreset, tafTranslations };