@opengeoweb/api 19.1.0 → 19.2.0

package/dist/README.md

@@ -0,0 +1,224 @@
+![current version](https://img.shields.io/badge/dynamic/json?color=blue&label=version&query=version&url=https://gitlab.com/opengeoweb/opengeoweb/raw/master/libs/api/package.json)
+![coverage](https://gitlab.com/opengeoweb/opengeoweb/badges/master/coverage.svg?job=test-api)
+
+# content
+
+- [api](#api)
+  - [Running unit tests](#running-unit-tests)
+  - [Setup the api](#setup-the-api)
+    - [1. Define a type for the api.](#1-define-a-type-for-the-api)
+    - [2. Define routes for your api.](#2-define-routes-for-your-api)
+    - [3. Create a createApi method to initiate the api](#3-create-a-createapi-method-to-initiate-the-api)
+    - [4. Define a baseURL inside config.json](#4-define-a-baseurl-inside-configjson)
+    - [5. Define a `fakeApi`.](#5-define-a--fakeapi-)
+  - [How to use the api](#how-to-use-the-api)
+    - [Use api inside app for production (api.ts)](#use-api-inside-app-for-production--apits-)
+    - [Use (fake)api inside libs for storybook](#use--fake-api-inside-libs-for-storybook)
+    - [Use the `useApiContext` to access the api or fakeApi](#use-the--useapicontext--to-access-the-api-or-fakeapi)
+
+<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
+
+# Api
+
+This library was generated with [Nx](https://nx.dev). The api lib makes it possible to use `ApiProvider` to wrap your components and make the `api` accessible by using the `useApiContext` hook.
+
+## Running unit tests
+
+Run `nx test api` to execute the unit tests via [Jest](https://jestjs.io).
+
+## Setup the api
+
+### 1. Define a type for the api.
+
+Create a file called `api`, and create a type for the api. This should be a type that returns promises. Example:
+
+```
+// api.ts
+export type AppApi = {
+  getInitialPresets: (
+    config: ConfigType,
+  ) => Promise<{ data: InitialAppPreset }>;
+  getScreenPresets: (
+    config: ConfigType,
+  ) => Promise<{ data: WorkspacePreset[] }>;
+  getBeVersion: () => Promise<{ data: { version: string } }>;
+};
+```
+
+### 2. Define routes for your api.
+
+This should be a method that returns the routes. Example:
+
+```
+// api.ts
+const getApiRoutes = (axiosInstance: AxiosInstance): AppApi => ({
+  getInitialPresets: (
+    formData: FormData,
+  ): Promise<{ data: InitialAppPreset }> => {
+    return axiosInstance.get('/getInitialPresetsUrl', formData);
+  },
+  getScreenPresets: (
+    formData: FormData,
+  ): Promise<{ data: WorkspacePreset[] }> => {
+    return axiosInstance.get('/getScreenPresets', formData);
+  },
+  getBeVersion: (): Promise<{ data: { version: string } }> => {
+    return axiosInstance.get('/version');
+  },
+});
+```
+
+### 3. Create a createApi method to initiate the api
+
+At GeoWeb we use `axios` to do request to apis. Since we also need authentication, we can't use our defined api directly, so create a small helper method to combine the axiosInstance with our api:
+
+```
+// api.ts
+import { createApiInstance } from '@opengeoweb/api';
+
+export const createApi = ({
+  url: string,
+  appURL: string,
+  auth: Credentials,
+  setAuth: (cred: Credentials) => void,
+  authTokenURL: string,
+  authClientId: string,
+}): AppApi => {
+  const axiosInstance = createApiInstance(
+    url,
+    appURL,
+    auth,
+    setAuth,
+    authTokenURL,
+    authClientId,
+  );
+
+  return getApiRoutes(axiosInstance);
+};
+
+```
+
+### 4. Define a baseURL inside config.json
+
+Your api needs a baseURL in order to work. Add this key to the config.json. Be aware, this involves more changes in other repositories. Example:
+
+```
+// config.json
+{
+   ...
+  "GW_MY_NEW_TEST_API_URL": 'https://mynewapi.com/v3'
+}
+```
+
+### 5. Define a `fakeApi`.
+
+Since storybook can't handle authenthication we need to mock the api with dummy data locally. It's also nice for testing functionality out without to have the geoweb app running. Create a new file called `fakeApi`, and add the same apiRoutes but let it return dummy data. Example:
+
+```
+// fakeApi.ts
+export const createFakeApi = (): AppApi => {
+  const api = {
+    // dummy calls
+    getInitialPresets: (): Promise<{ data: InitialAppPreset }> =>
+      Promise.resolve({
+        data: defaultInitialPresets as InitialAppPreset,
+      }),
+    getScreenPresets: (): Promise<{
+      data: WorkspacePreset[];
+    }> =>
+      Promise.resolve({
+        data: defaultScreenPresets as WorkspacePreset[],
+      }),
+    getBeVersion: (): Promise<{ data: { version: string } }> =>
+      Promise.resolve({ data: { version: 'version 1.0.1' } }),
+  };
+
+  return api;
+};
+```
+
+Also create a `createApi` method. Since we're not doing real requests with axios with this, we won't need it and use the `fakeAxiosInstance`. Example:
+
+```
+// fakeApi.ts
+import { createFakeApiInstance } from '@opengeoweb/api';
+export const createApi = (): TafApi => {
+  const instance = createFakeApiInstance();
+  return getApiRoutes(instance);
+};
+```
+
+## How to use the api
+
+If you follow the steps above, you end up with 2 new files (api.ts and fakeApi.ts) and a new config key for the json.
+
+#### Use api inside app for production (api.ts)
+
+If you want to try the api out with real data, you should do this inside the `app`. First, wrap the component which needs the api with the ApiProvider, and pass the `createApi` method from the api:
+
+```
+// app/geoweb/components/MyNewModule
+  <ApiProvider
+      baseURL={config.GW_MY_NEW_TEST_API_URL}
+      appURL={config.GW_APP_URL}
+      auth={auth}
+      onSetAuth={onSetAuth}
+      createApi={createApi} // coming fron api.ts
+      authTokenURL={config.GW_AUTH_TOKEN_URL}
+      authClientId={config.GW_AUTH_CLIENT_ID}
+    >
+      <ErrorBoundary>
+        <MyNewModule />
+      </ErrorBoundary>
+    </ApiProvider>
+```
+
+The `baseURL` should get the url you've defined earlier. The `createApi` should pass the `createApi` method we've defined. The rest of the props you can pass from the props of geoweb.
+
+#### Use (fake)api inside libs for storybook
+
+If you want to try the api out with fake data, you should do this inside storybook. First, wrap the component which needs the api with the ApiProvider. and pass the `createApi` method from the fakeApi:
+
+```
+// libs/myNewLib/src/lib/MyNewLibDemo.stories.tsx
+  <ApiProvider
+      createApi={createApi} // coming fron fakeApi.ts
+    >
+      <ErrorBoundary>
+        <MyNewModule />
+      </ErrorBoundary>
+    </ApiProvider>
+```
+
+#### Use the `useApiContext` inside a component to access the api or fakeApi
+
+Inside your component you can use the `useApiContext` to access the defined routes. Please note that the `ApiProvider` needs to be used around one of the parent components for this to work. Any story or tests should therefore also be wrapped:
+
+```
+const MyComponent: React.FC = () => {
+  const { api } = useApiContext<AppApi>();
+  const [initialPresets, setInitialPresets] = React.useState<InitialAppPreset>([]);
+
+  React.useEffect(()=> {
+    const intitialPresets = await api.getInitialPresets(myFormvalues);
+    setInitialAppPresets(intitialPresets);
+  }, []);
+
+  return <>initialPresets.map(preset => preset.name)</>
+};
+
+export const StoryBookExample = (): React.ReactElement => (
+  <ApiProvider
+    createApi={createApi} // coming fron fakeApi.ts
+  >
+      <ErrorBoundary>
+        <MyComponent />
+      </ErrorBoundary>
+  </ApiProvider>
+);
+
+```
+
+### TypeScript Documentation
+
+- [TypeScript Docs](https://opengeoweb.gitlab.io/opengeoweb/typescript-docs/api/)

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.esm.js

@@ -0,0 +1,588 @@
+import { useAuthenticationContext } from '@opengeoweb/authentication';
+export * from '@opengeoweb/authentication';
+import { useQuery, QueryClientProvider } from '@tanstack/react-query';
+import { omit } from 'lodash';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
+import React from 'react';
+import { QueryClient, keepPreviousData } from '@tanstack/query-core';
+
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+
+var getHeaders = function getHeaders(auth) {
+  return omit({
+    'Content-Type': 'application/json',
+    Authorization: "Bearer " + (auth == null ? void 0 : auth.token),
+    Accept: 'application/json'
+  }, auth ? [] : ['Authorization']);
+};
+var withJsonFormat = function withJsonFormat(url) {
+  var urlObj = new URL(url);
+  urlObj.searchParams.set('f', 'json');
+  return urlObj.toString();
+};
+// This function has a copy in libs/webmap-react/src/lib/edr-layer-api/api.ts. This cannot be used there due to circular dependency
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var handleResponse = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(response) {
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          if (!response.ok) {
+            _context.n = 1;
+            break;
+          }
+          return _context.a(2, response.json().then(function (json) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return json != null ? json : response.headers;
+          })["catch"](function () {
+            // No JSON response
+          }));
+        case 1:
+          return _context.a(2, response.json()["catch"](function () {
+            // Couldn't parse the JSON
+            throw new Error("" + response.status);
+          }).then(function (json) {
+            // Got valid JSON with error response, use it
+            if (json) {
+              var message = json.message;
+              if (message) {
+                throw new Error(message, {
+                  cause: response.status
+                });
+              }
+              var result = JSON.stringify(json);
+              throw new Error(result);
+            }
+            throw new Error("" + response.status);
+          }));
+      }
+    }, _callee);
+  }));
+  return function handleResponse(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var useAuthQuery = function useAuthQuery(queryKey, _queryFn, disabled, refetchInterval) {
+  if (disabled === void 0) {
+    disabled = false;
+  }
+  if (refetchInterval === void 0) {
+    refetchInterval = false;
+  }
+  var _useAuthenticationCon = useAuthenticationContext(),
+    auth = _useAuthenticationCon.auth;
+  var enabled = !!auth && !disabled;
+  return useQuery({
+    queryKey: queryKey,
+    queryFn: function () {
+      var _queryFn2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              return _context2.a(2, _queryFn(auth));
+          }
+        }, _callee2);
+      }));
+      function queryFn() {
+        return _queryFn2.apply(this, arguments);
+      }
+      return queryFn;
+    }(),
+    enabled: enabled,
+    refetchInterval: refetchInterval
+  });
+};
+var optimisticUpdate = function optimisticUpdate(updatedQueryKey, queryClient, _optimisticUpdate, errorCallback) {
+  return {
+    onMutate: function () {
+      var _onMutate = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(variables) {
+        var oldData;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              void queryClient.cancelQueries({
+                queryKey: updatedQueryKey
+              });
+              oldData = queryClient.getQueryData(updatedQueryKey);
+              if (variables.id) {
+                queryClient.setQueryData(updatedQueryKey, function (old) {
+                  return old == null ? void 0 : old.map(function (item) {
+                    return item.id === variables.id ? _optimisticUpdate(item, variables) : item;
+                  });
+                });
+              }
+              return _context3.a(2, {
+                oldData: oldData
+              });
+          }
+        }, _callee3);
+      }));
+      function onMutate(_x2) {
+        return _onMutate.apply(this, arguments);
+      }
+      return onMutate;
+    }(),
+    onError: function onError(err, _, context) {
+      if (context != null && context.oldData) {
+        queryClient.setQueryData(updatedQueryKey, context == null ? void 0 : context.oldData);
+      }
+      if (errorCallback) {
+        errorCallback(err);
+      }
+    }
+  };
+};
+
+/* *
+ * 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 wait = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(delayDuration) {
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          return _context.a(2, new Promise(function (resolve) {
+            setTimeout(resolve, delayDuration);
+          }));
+      }
+    }, _callee);
+  }));
+  return function wait(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var makeMockApiCall = function makeMockApiCall(response, responseInit, delayDuration) {
+  if (delayDuration === void 0) {
+    delayDuration = 0;
+  }
+  if (delayDuration) {
+    return jest.fn().mockImplementation(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+      return _regenerator().w(function (_context2) {
+        while (1) switch (_context2.n) {
+          case 0:
+            _context2.n = 1;
+            return wait(delayDuration);
+          case 1:
+            return _context2.a(2, Response.json(response, responseInit));
+        }
+      }, _callee2);
+    })));
+  }
+  return jest.fn().mockImplementation(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 0:
+          return _context3.a(2, Promise.resolve(Response.json(response, responseInit)));
+      }
+    }, _callee3);
+  })));
+};
+
+/* *
+ * 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 2024 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2024 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+/**
+ * ProductStatus is returned by the backend. The backend fills in  this property.
+ * For the backend, it should only need to store 'DRAFT' | 'PUBLISHED' | 'CANCELLED' in its DB.
+ * The backend should derive and return the status 'EXPIRED' from the product properties.
+ *
+ * Note: ProductStatus from the backend should be refreshed regularly to display status updates. */
+var ProductStatus;
+(function (ProductStatus) {
+  ProductStatus["DRAFT"] = "DRAFT";
+  ProductStatus["PUBLISHED"] = "PUBLISHED";
+  ProductStatus["RENEWED"] = "RENEWED";
+  ProductStatus["CANCELLED"] = "CANCELLED";
+  ProductStatus["EXPIRED"] = "EXPIRED";
+  ProductStatus["DISCARDED"] = "DISCARDED";
+})(ProductStatus || (ProductStatus = {}));
+var LevelUnits;
+(function (LevelUnits) {
+  LevelUnits["FT"] = "ft";
+  LevelUnits["M"] = "m";
+  LevelUnits["FL"] = "FL";
+})(LevelUnits || (LevelUnits = {}));
+var CloudLevelUnits;
+(function (CloudLevelUnits) {
+  CloudLevelUnits["FT"] = "ft";
+  CloudLevelUnits["M"] = "m";
+})(CloudLevelUnits || (CloudLevelUnits = {}));
+/**
+ * The possible phenomena for the sigmet
+ */
+var SigmetPhenomena;
+(function (SigmetPhenomena) {
+  SigmetPhenomena["EMBD_TS"] = "Embedded thunderstorm(s)";
+  SigmetPhenomena["EMBD_TSGR"] = "Embedded thunderstorm(s) with hail";
+  SigmetPhenomena["FRQ_TS"] = "Frequent thunderstorm(s)";
+  SigmetPhenomena["FRQ_TSGR"] = "Frequent thunderstorm(s) with hail";
+  SigmetPhenomena["HVY_DS"] = "Heavy duststorm";
+  SigmetPhenomena["HVY_SS"] = "Heavy sandstorm";
+  SigmetPhenomena["OBSC_TS"] = "Obscured thunderstorm(s)";
+  SigmetPhenomena["OBSC_TSGR"] = "Obscured thunderstorm(s) with hail";
+  SigmetPhenomena["RDOACT_CLD"] = "Radioactive cloud";
+  SigmetPhenomena["SEV_ICE"] = "Severe icing";
+  SigmetPhenomena["SEV_ICE_FRZ_RN"] = "Severe icing due to freezing rain";
+  SigmetPhenomena["SEV_MTW"] = "Severe mountain wave";
+  SigmetPhenomena["SEV_TURB"] = "Severe turbulence";
+  SigmetPhenomena["SQL_TS"] = "Squall line thunderstorm(s)";
+  SigmetPhenomena["SQL_TSGR"] = "Squall line thunderstorm(s) with hail";
+  // 'TC' = 'Tropical cyclone',     // Don't show this option in the list because it will be not used by KNMI.
+  SigmetPhenomena["VA_CLD"] = "Volcanic ash cloud";
+})(SigmetPhenomena || (SigmetPhenomena = {}));
+/**
+ * The possible phenomena for the airmet
+ */
+var AirmetPhenomena;
+(function (AirmetPhenomena) {
+  AirmetPhenomena["SFC_VIS"] = "Surface visibility";
+  AirmetPhenomena["SFC_WIND"] = "Surface wind";
+  AirmetPhenomena["OVC_CLD"] = "Overcast cloud";
+  AirmetPhenomena["BKN_CLD"] = "Broken cloud";
+  AirmetPhenomena["ISOL_CB"] = "Isolated cumulonimbus cloud";
+  AirmetPhenomena["OCNL_CB"] = "Occasional cumulonimbus cloud";
+  AirmetPhenomena["FRQ_CB"] = "Frequent cumulonimbus cloud";
+  AirmetPhenomena["ISOL_TS"] = "Isolated thunderstorm(s)";
+  AirmetPhenomena["OCNL_TS"] = "Occasional thunderstorm(s)";
+  AirmetPhenomena["ISOL_TSGR"] = "Isolated thunderstorm(s) with hail";
+  AirmetPhenomena["OCNL_TSGR"] = "Occasional thunderstorm(s) with hail";
+  AirmetPhenomena["ISOL_TCU"] = "Isolated towering cumulus cloud";
+  AirmetPhenomena["OCNL_TCU"] = "Occasional towering cumulus cloud";
+  AirmetPhenomena["FRQ_TCU"] = "Frequent towering cumulus cloud";
+  AirmetPhenomena["MOD_ICE"] = "Moderate icing";
+  AirmetPhenomena["MOD_MTW"] = "Moderate mountain wave";
+  AirmetPhenomena["MOD_TURB"] = "Moderate turbulence";
+  AirmetPhenomena["MT_OBSC"] = "Mountains obscured";
+})(AirmetPhenomena || (AirmetPhenomena = {}));
+/* Speed unit, e.g. 'KT', 'KMH' */
+var MovementUnit;
+(function (MovementUnit) {
+  MovementUnit["KT"] = "kt";
+  MovementUnit["KMH"] = "kmh";
+})(MovementUnit || (MovementUnit = {}));
+// can these be unified as SpeedUnit?
+var WindUnit;
+(function (WindUnit) {
+  WindUnit["KT"] = "kt";
+  WindUnit["MPS"] = "mps";
+})(WindUnit || (WindUnit = {}));
+var Direction;
+(function (Direction) {
+  Direction["N"] = "N";
+  Direction["NNE"] = "NNE";
+  Direction["NE"] = "NE";
+  Direction["ENE"] = "ENE";
+  Direction["E"] = "E";
+  Direction["ESE"] = "ESE";
+  Direction["SE"] = "SE";
+  Direction["SSE"] = "SSE";
+  Direction["S"] = "S";
+  Direction["SSW"] = "SSW";
+  Direction["SW"] = "SW";
+  Direction["WSW"] = "WSW";
+  Direction["W"] = "W";
+  Direction["WNW"] = "WNW";
+  Direction["NW"] = "NW";
+  Direction["NNW"] = "NNW";
+})(Direction || (Direction = {}));
+var VisibilityCause;
+(function (VisibilityCause) {
+  VisibilityCause["DZ"] = "Drizzle";
+  VisibilityCause["DU"] = "Dust";
+  VisibilityCause["PO"] = "Dust or sand devil";
+  VisibilityCause["DS"] = "Dust storm";
+  VisibilityCause["FG"] = "Fog";
+  VisibilityCause["FC"] = "Funnel clouds";
+  VisibilityCause["GR"] = "Hail";
+  VisibilityCause["HZ"] = "Haze";
+  VisibilityCause["PL"] = "Ice pellets";
+  VisibilityCause["BR"] = "Mist";
+  VisibilityCause["RA"] = "Rain";
+  VisibilityCause["SA"] = "Sand";
+  VisibilityCause["SS"] = "Sand storm";
+  VisibilityCause["FU"] = "Smoke";
+  VisibilityCause["SN"] = "Snow";
+  VisibilityCause["SG"] = "Snow grains";
+  VisibilityCause["GS"] = "Soft hail";
+  VisibilityCause["SQ"] = "Squalls";
+  VisibilityCause["VA"] = "Volcanic Ash";
+})(VisibilityCause || (VisibilityCause = {}));
+
+/* *
+ * 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 queryClientInstance = null;
+var getQueryClient = function getQueryClient() {
+  queryClientInstance != null ? queryClientInstance : queryClientInstance = new QueryClient({
+    defaultOptions: {
+      queries: {
+        refetchOnWindowFocus: false,
+        refetchOnMount: false,
+        refetchOnReconnect: false,
+        refetchInterval: false,
+        placeholderData: keepPreviousData,
+        staleTime: 1000 * 60 * 5
+      }
+    }
+  });
+  return queryClientInstance;
+};
+var setQueryClient = function setQueryClient(client) {
+  queryClientInstance = client;
+};
+var configureLibraryDefaults = function configureLibraryDefaults(queryKeyPrefix, options) {
+  var client = getQueryClient();
+  client.setQueryDefaults(queryKeyPrefix, options);
+};
+var createTestQueryClient = function createTestQueryClient(overrides) {
+  var client = new QueryClient({
+    defaultOptions: {
+      queries: Object.assign({
+        retry: false,
+        staleTime: 0,
+        gcTime: 0,
+        refetchOnWindowFocus: false,
+        refetchOnMount: false,
+        refetchOnReconnect: false,
+        refetchInterval: false
+      }, overrides == null ? void 0 : overrides.queries),
+      mutations: Object.assign({
+        retry: false
+      }, overrides == null ? void 0 : overrides.mutations)
+    }
+  });
+  setQueryClient(client);
+  return client;
+};
+var resetQueryClient = function resetQueryClient() {
+  var _queryClientInstance, _queryClientInstance2;
+  void ((_queryClientInstance = queryClientInstance) == null ? void 0 : _queryClientInstance.cancelQueries());
+  (_queryClientInstance2 = queryClientInstance) == null || _queryClientInstance2.clear();
+  queryClientInstance = null;
+};
+
+var QueryClientProviderWrapper = function QueryClientProviderWrapper(_ref) {
+  var client = _ref.client,
+    children = _ref.children,
+    _ref$mode = _ref.mode,
+    mode = _ref$mode === void 0 ? 'production' : _ref$mode;
+  var queryClient = React.useMemo(function () {
+    if (client) {
+      setQueryClient(client);
+      return client;
+    }
+    return mode === 'test' ? createTestQueryClient() : getQueryClient();
+  }, [client, mode]);
+  return jsxs(QueryClientProvider, {
+    client: queryClient,
+    children: [children, jsx("div", {
+      style: {
+        position: 'fixed',
+        left: 8,
+        bottom: '5%',
+        zIndex: 99999
+      },
+      children: jsx(ReactQueryDevtools, {
+        buttonPosition: "relative",
+        initialIsOpen: false
+      })
+    })]
+  });
+};
+
+/* *
+ * 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 2024 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2024 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var API_NAMESPACE = 'api';
+// Initialize and create provider if needed
+
+export { API_NAMESPACE, AirmetPhenomena, CloudLevelUnits, Direction, LevelUnits, MovementUnit, ProductStatus, QueryClientProviderWrapper, SigmetPhenomena, VisibilityCause, WindUnit, configureLibraryDefaults, createTestQueryClient, getHeaders, getQueryClient, handleResponse, makeMockApiCall, optimisticUpdate, resetQueryClient, setQueryClient, useAuthQuery, withJsonFormat };

package/dist/src/fakeApi.d.ts

@@ -0,0 +1,3 @@
+type JsonBodyType = unknown;
+export declare const makeMockApiCall: (response: JsonBodyType, responseInit?: ResponseInit, delayDuration?: number) => jest.Mock;
+export {};

package/dist/src/i18n.d.ts

@@ -0,0 +1 @@
+export declare const API_NAMESPACE = "api";

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from '@opengeoweb/authentication';
+export * from './utils';
+export * from './fakeApi';
+export type * from './sigmet-airmet-api/types';
+export * from './sigmet-airmet-api/definitions';
+export type * from './sigmet-airmet-api/config-types';
+export * from './query-client';
+export { API_NAMESPACE } from './i18n';

package/dist/src/query-client/QueryClientProviderWrapper.d.ts

@@ -0,0 +1,9 @@
+import type { QueryClient } from '@tanstack/query-core';
+import React from 'react';
+interface QueryClientProviderWrapperProps {
+    client?: QueryClient;
+    children: React.ReactNode;
+    mode?: 'test' | 'production';
+}
+export declare const QueryClientProviderWrapper: ({ client, children, mode, }: QueryClientProviderWrapperProps) => React.ReactElement;
+export {};

package/dist/src/query-client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QueryClientProviderWrapper';
+export * from './queryClient';

package/dist/src/query-client/queryClient.d.ts

@@ -0,0 +1,10 @@
+import type { DefaultOptions } from '@tanstack/query-core';
+import { QueryClient } from '@tanstack/query-core';
+export declare const getQueryClient: () => QueryClient;
+export declare const setQueryClient: (client: QueryClient) => void;
+export declare const configureLibraryDefaults: (queryKeyPrefix: string[], options: DefaultOptions["queries"]) => void;
+export declare const createTestQueryClient: (overrides?: {
+    queries?: DefaultOptions["queries"];
+    mutations?: DefaultOptions["mutations"];
+}) => QueryClient;
+export declare const resetQueryClient: () => void;

package/dist/src/sigmet-airmet-api/config-types.d.ts

@@ -0,0 +1,88 @@
+import type { MapPreset } from '@opengeoweb/store';
+export interface AllowedUnits {
+    unit_type: string;
+    allowed_units: string[];
+}
+export type FIRLocationGeoJson = GeoJSON.FeatureCollection<GeoJSON.Geometry, {
+    selectionType?: string;
+}>;
+export interface LevelMinMaxType {
+    FT?: number;
+    FL?: number;
+    M?: number;
+}
+export interface MovementMinMaxType {
+    KT?: number;
+    KMH?: number;
+}
+export interface CloudLevelMinMaxType {
+    FT?: number;
+    M?: number;
+}
+export interface SurfaceWindMinMaxType {
+    KT?: number;
+    MPS?: number;
+}
+export interface FIRArea {
+    fir_name: string;
+    fir_location: FIRLocationGeoJson;
+    location_indicator_atsr: string;
+    location_indicator_atsu: string;
+    max_hours_of_validity: number;
+    hours_before_validity: number;
+    level_min?: LevelMinMaxType;
+    level_max?: LevelMinMaxType;
+    level_rounding_FL?: number;
+    level_rounding_FT?: number;
+    level_rounding_M?: number;
+    movement_min?: MovementMinMaxType;
+    movement_max?: MovementMinMaxType;
+    movement_rounding_kt?: number;
+    movement_rounding_kmh?: number;
+    max_polygon_points?: number;
+    units: AllowedUnits[];
+}
+export interface FIRConfigSigmet extends FIRArea {
+    tc_max_hours_of_validity: number;
+    tc_hours_before_validity: number;
+    va_max_hours_of_validity: number;
+    va_hours_before_validity: number;
+    va_cld_degrees_minutes?: boolean;
+    adjacent_firs: string[];
+}
+export interface FIRConfigAirmet extends FIRArea {
+    cloud_level_min?: CloudLevelMinMaxType;
+    cloud_level_max?: CloudLevelMinMaxType;
+    cloud_lower_level_min?: CloudLevelMinMaxType;
+    cloud_lower_level_max?: CloudLevelMinMaxType;
+    cloud_level_rounding_ft?: number;
+    cloud_level_rounding_m_below?: number;
+    cloud_level_rounding_m_above?: number;
+    wind_direction_rounding?: number;
+    wind_speed_max?: SurfaceWindMinMaxType;
+    wind_speed_min?: SurfaceWindMinMaxType;
+    visibility_max?: number;
+    visibility_min?: number;
+    visibility_rounding_below?: number;
+    visibility_rounding_above?: number;
+}
+type SigmetFIRArea = Record<string, FIRConfigSigmet>;
+type AirmetFIRArea = Record<string, FIRConfigAirmet>;
+export type Firareas = SigmetFIRArea | AirmetFIRArea;
+export interface ProductConfig {
+    location_indicator_mwo: string;
+    active_firs: string[];
+    valid_from_delay_minutes: number;
+    default_validity_minutes: number;
+    fir_areas: Firareas;
+    mapPreset?: MapPreset;
+    omit_change_va_and_rdoact_cloud?: boolean;
+    disable_amend_action?: boolean;
+}
+export interface SigmetConfig extends ProductConfig {
+    fir_areas: SigmetFIRArea;
+}
+export interface AirmetConfig extends ProductConfig {
+    fir_areas: AirmetFIRArea;
+}
+export {};

package/dist/src/sigmet-airmet-api/definitions.d.ts

@@ -0,0 +1,142 @@
+export type DateType = string;
+export type ICAOLocation = string;
+export type MWOLocation = string;
+export type ATSULocation = string;
+export type ATSRLocation = string;
+/**
+ * ProductStatus is returned by the backend. The backend fills in  this property.
+ * For the backend, it should only need to store 'DRAFT' | 'PUBLISHED' | 'CANCELLED' in its DB.
+ * The backend should derive and return the status 'EXPIRED' from the product properties.
+ *
+ * Note: ProductStatus from the backend should be refreshed regularly to display status updates. */
+export declare enum ProductStatus {
+    DRAFT = "DRAFT",
+    PUBLISHED = "PUBLISHED",
+    RENEWED = "RENEWED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED",
+    DISCARDED = "DISCARDED"
+}
+/**
+ * ProductSequence is a sequence label with a counter of the SIGMETs/AIRMETs issued on a day (starting at with 1 01:00),
+ * max 3 characters long; first character should be a capital letter,
+ * others are numbers: A01-A99, 01-99 or 1-99 */
+export type ProductSequenceId = string;
+/**
+ *  ProductCanbe lifecycle is determined by the backend. E.g. the backend fills in these properties:
+ * 'DRAFTED': product can be saved as draft
+ * 'DISCARDED': This product can be thrown away
+ * 'PUBLISHED': product can be PUBLISHED
+ * 'CANCELLED': product can be CANCELLED */
+export type ProductCanbe = 'DRAFTED' | 'DISCARDED' | 'PUBLISHED' | 'RENEWED' | 'CANCELLED';
+export type ObservationOrForcast = 'OBS' | 'FCST';
+export declare enum LevelUnits {
+    'FT' = "ft",
+    'M' = "m",
+    'FL' = "FL"
+}
+export declare enum CloudLevelUnits {
+    'FT' = "ft",
+    'M' = "m"
+}
+/** Change type of the Product, can be:
+ * INTSF:Intensifying
+ * WKN: Weakening
+ * NC: No change */
+export type Change = 'INTSF' | 'WKN' | 'NC';
+export type LevelInfoMode = 'AT' | 'BETW' | 'BETW_SFC' | 'TOPS' | 'TOPS_ABV' | 'TOPS_BLW' | 'ABV';
+/**
+ * The possible phenomena for the sigmet
+ */
+export declare enum SigmetPhenomena {
+    'EMBD_TS' = "Embedded thunderstorm(s)",
+    'EMBD_TSGR' = "Embedded thunderstorm(s) with hail",
+    'FRQ_TS' = "Frequent thunderstorm(s)",
+    'FRQ_TSGR' = "Frequent thunderstorm(s) with hail",
+    'HVY_DS' = "Heavy duststorm",
+    'HVY_SS' = "Heavy sandstorm",
+    'OBSC_TS' = "Obscured thunderstorm(s)",
+    'OBSC_TSGR' = "Obscured thunderstorm(s) with hail",
+    'RDOACT_CLD' = "Radioactive cloud",
+    'SEV_ICE' = "Severe icing",
+    'SEV_ICE_FRZ_RN' = "Severe icing due to freezing rain",
+    'SEV_MTW' = "Severe mountain wave",
+    'SEV_TURB' = "Severe turbulence",
+    'SQL_TS' = "Squall line thunderstorm(s)",
+    'SQL_TSGR' = "Squall line thunderstorm(s) with hail",
+    'VA_CLD' = "Volcanic ash cloud"
+}
+/**
+ * The possible phenomena for the airmet
+ */
+export declare enum AirmetPhenomena {
+    'SFC_VIS' = "Surface visibility",
+    'SFC_WIND' = "Surface wind",
+    'OVC_CLD' = "Overcast cloud",
+    'BKN_CLD' = "Broken cloud",
+    'ISOL_CB' = "Isolated cumulonimbus cloud",
+    'OCNL_CB' = "Occasional cumulonimbus cloud",
+    'FRQ_CB' = "Frequent cumulonimbus cloud",
+    'ISOL_TS' = "Isolated thunderstorm(s)",
+    'OCNL_TS' = "Occasional thunderstorm(s)",
+    'ISOL_TSGR' = "Isolated thunderstorm(s) with hail",
+    'OCNL_TSGR' = "Occasional thunderstorm(s) with hail",
+    'ISOL_TCU' = "Isolated towering cumulus cloud",
+    'OCNL_TCU' = "Occasional towering cumulus cloud",
+    'FRQ_TCU' = "Frequent towering cumulus cloud",
+    'MOD_ICE' = "Moderate icing",
+    'MOD_MTW' = "Moderate mountain wave",
+    'MOD_TURB' = "Moderate turbulence",
+    'MT_OBSC' = "Mountains obscured"
+}
+export type SigmetMovementType = 'STATIONARY' | 'MOVEMENT' | 'FORECAST_POSITION' | 'NO_VA_EXP';
+export type AirmetMovementType = 'STATIONARY' | 'MOVEMENT';
+export declare enum MovementUnit {
+    'KT' = "kt",
+    'KMH' = "kmh"
+}
+export declare enum WindUnit {
+    'KT' = "kt",
+    'MPS' = "mps"
+}
+export declare enum Direction {
+    'N' = "N",
+    'NNE' = "NNE",
+    'NE' = "NE",
+    'ENE' = "ENE",
+    'E' = "E",
+    'ESE' = "ESE",
+    'SE' = "SE",
+    'SSE' = "SSE",
+    'S' = "S",
+    'SSW' = "SSW",
+    'SW' = "SW",
+    'WSW' = "WSW",
+    'W' = "W",
+    'WNW' = "WNW",
+    'NW' = "NW",
+    'NNW' = "NNW"
+}
+export type VisibilityUnit = 'm';
+export declare enum VisibilityCause {
+    'DZ' = "Drizzle",
+    'DU' = "Dust",
+    'PO' = "Dust or sand devil",
+    'DS' = "Dust storm",
+    'FG' = "Fog",
+    'FC' = "Funnel clouds",
+    'GR' = "Hail",
+    'HZ' = "Haze",
+    'PL' = "Ice pellets",
+    'BR' = "Mist",
+    'RA' = "Rain",
+    'SA' = "Sand",
+    'SS' = "Sand storm",
+    'FU' = "Smoke",
+    'SN' = "Snow",
+    'SG' = "Snow grains",
+    'GS' = "Soft hail",
+    'SQ' = "Squalls",
+    'VA' = "Volcanic Ash"
+}
+export type CloudLevelInfoMode = 'BETW' | 'BETW_SFC' | 'BETW_SFC_ABV' | 'BETW_ABV';

package/dist/src/sigmet-airmet-api/types.d.ts

@@ -0,0 +1,101 @@
+import type { AirmetMovementType, AirmetPhenomena, ATSRLocation, ATSULocation, Change, CloudLevelInfoMode, CloudLevelUnits, DateType, Direction, ICAOLocation, LevelInfoMode, LevelUnits, MovementUnit, MWOLocation, ObservationOrForcast, ProductCanbe, ProductSequenceId, ProductStatus, SigmetMovementType, SigmetPhenomena, VisibilityCause, VisibilityUnit, WindUnit } from './definitions';
+export interface LevelType {
+    value: number;
+    unit: LevelUnits;
+}
+export interface CloudLevelType {
+    value: number;
+    unit: CloudLevelUnits;
+}
+export interface Coordinate {
+    latitude: number;
+    longitude: number;
+}
+export interface BaseProduct {
+    validDateStart: DateType;
+    validDateEnd: DateType;
+    firName: ICAOLocation;
+    locationIndicatorMWO: MWOLocation;
+    locationIndicatorATSU: ATSULocation;
+    locationIndicatorATSR: ATSRLocation;
+    uuid?: string;
+    sequence?: ProductSequenceId;
+    issueDate?: DateType;
+    author?: string;
+}
+interface Product extends BaseProduct {
+    status: ProductStatus;
+    isObservationOrForecast?: ObservationOrForcast;
+    observationOrForecastTime?: DateType;
+    change?: Change;
+    levelInfoMode?: LevelInfoMode;
+    level?: LevelType;
+    lowerLevel?: LevelType;
+    firGeometry?: GeoJSON.FeatureCollection;
+    startGeometry: GeoJSON.FeatureCollection;
+    startGeometryIntersect: GeoJSON.FeatureCollection;
+    movementSpeed?: number;
+    movementUnit?: MovementUnit;
+    movementDirection?: Direction;
+}
+export interface Sigmet extends Product {
+    phenomenon: SigmetPhenomena;
+    type: 'NORMAL' | 'TEST' | 'EXERCISE' | 'SHORT_TEST' | 'SHORT_VA_TEST';
+    endGeometry?: GeoJSON.FeatureCollection;
+    endGeometryIntersect?: GeoJSON.FeatureCollection;
+    movementType?: SigmetMovementType;
+    /** Extra properties in case of va SIGMET */
+    vaSigmetVolcanoName?: string;
+    vaSigmetVolcanoCoordinates?: Coordinate;
+    /** Extra properties in case of cancel va SIGMET, if set to unknown, property not set */
+    vaSigmetMoveToFIR?: ICAOLocation;
+}
+/**
+ * To cancel a published sigmet
+ * To cancel a published sigmet, we send a cancel sigmet with all the mandatory properties from the basesigmet. */
+export interface CancelSigmet extends BaseProduct {
+    cancelsSigmetSequenceId: ProductSequenceId;
+    validDateStartOfSigmetToCancel: DateType;
+    validDateEndOfSigmetToCancel: DateType;
+    status: ProductStatus.PUBLISHED;
+    /** Extra properties in case of cancel va SIGMET, if set to unknown, property not set */
+    vaSigmetMoveToFIR?: ICAOLocation;
+}
+export interface Airmet extends Product {
+    phenomenon: AirmetPhenomena;
+    status: ProductStatus;
+    type: 'NORMAL' | 'TEST' | 'EXERCISE';
+    movementType: AirmetMovementType;
+    windSpeed?: number;
+    windUnit?: WindUnit;
+    windDirection?: number;
+    visibilityValue?: number;
+    visibilityCause?: VisibilityCause;
+    visibilityUnit?: VisibilityUnit;
+    cloudLevelInfoMode?: CloudLevelInfoMode;
+    cloudLevel?: CloudLevelType;
+    cloudLowerLevel?: CloudLevelType;
+}
+export interface CancelAirmet extends BaseProduct {
+    cancelsAirmetSequenceId: ProductSequenceId;
+    validDateStartOfAirmetToCancel: DateType;
+    validDateEndOfAirmetToCancel: DateType;
+    status: ProductStatus.PUBLISHED;
+}
+export interface SigmetFromBackend {
+    sigmet: Sigmet | CancelSigmet;
+    creationDate: DateType;
+    lastUpdateDate: DateType;
+    uuid: string;
+    canbe: ProductCanbe[];
+    author?: string;
+}
+export interface AirmetFromBackend {
+    airmet: Airmet | CancelAirmet;
+    creationDate: DateType;
+    lastUpdateDate: DateType;
+    uuid: string;
+    canbe: ProductCanbe[];
+    author?: string;
+}
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,13 @@
+import type { MutationOptions, QueryClient, UseQueryResult } from '@tanstack/react-query';
+import type { Credentials } from '@opengeoweb/authentication';
+export declare const getHeaders: (auth?: Credentials) => HeadersInit;
+export declare const withJsonFormat: (url: string) => string;
+export declare const handleResponse: (response: Response) => Promise<any>;
+export declare const useAuthQuery: <T>(queryKey: string[], queryFn: (auth: Credentials) => Promise<T>, disabled?: boolean, refetchInterval?: number | false) => UseQueryResult<T>;
+export declare const optimisticUpdate: <U extends {
+    id?: string;
+}, T extends {
+    id?: string;
+}>(updatedQueryKey: string[], queryClient: QueryClient, optimisticUpdate: (oldValue: U, variables: T) => U, errorCallback?: (err: Error) => void) => MutationOptions<Headers | null, Error, T, {
+    oldData: U[] | undefined;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/api",
-  "version": "19.1.0",
+  "version": "19.2.0",
   "description": "GeoWeb API library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -32,6 +32,7 @@
   },
   "files": [
     "dist",
+    "!dist/package.json",
     "README.md",
     "package.json"
   ]