@hortiview/modulebase 0.0.1-7.1-beta

package/dist/lib/types/Entities.d.ts

@@ -0,0 +1,22 @@
+import { Block, BlockPlantLayout, Farm, FarmAlertRule, FarmOrganization, Field, IrrigationStation, Season } from '../types/ModuleApi';
+export type HortiviewDataAreaGroup = 'FarmOrganization' | 'FarmMember';
+export type ModuleDataAreaGroup = 'ModuleDepended';
+export type FarmOrganizationEntities = 'farms' | 'fields' | 'zones' | 'irrigation_stations' | 'farm_organizations' | 'alert_rules';
+export type FarmMemberEntities = 'farm_members';
+export type ModuleDependendEntities = 'Season' | 'BlockPlantLayout' | (string & {});
+export type HortiviewDataAreaEntity<T extends HortiviewDataAreaGroup | ModuleDataAreaGroup> = T extends 'FarmOrganization' ? FarmOrganizationEntities : T extends 'FarmMember' ? FarmMemberEntities : T extends 'ModuleDepended' ? ModuleDependendEntities : never;
+export type ResultMap<T extends FarmMemberEntities | FarmOrganizationEntities | ModuleDependendEntities> = T extends 'zones' ? Block : T extends 'fields' ? Field : T extends 'farms' ? Farm : T extends 'irrigation_stations' ? IrrigationStation : T extends 'farm_organizations' ? FarmOrganization : T extends 'alert_rules' ? FarmAlertRule : T extends 'Season' ? Season : T extends 'BlockPlantLayout' ? BlockPlantLayout : unknown;
+export declare const FarmOrgEntitiesTypeResultMap: Record<FarmOrganizationEntities, string>;
+export declare const FarmMemberEntitiesTypeResultMap: Record<FarmMemberEntities, string>;
+export declare const ModuleDependedEntityTypeResultMap: Record<ModuleDependendEntities, string>;
+export declare const AllEntitiesTypeResultMap: {
+    Season: string;
+    BlockPlantLayout: string;
+    farm_members: string;
+    farms: string;
+    fields: string;
+    zones: string;
+    irrigation_stations: string;
+    farm_organizations: string;
+    alert_rules: string;
+};

package/dist/lib/types/Environment.d.ts

@@ -0,0 +1,18 @@
+export interface HortiViewEnvironments {
+    COMMON_API: string;
+    MODULE_AUTH_API: string;
+    API_PREFIX: string;
+    ENVIRONMENT: string;
+    REQ_VERSION: string;
+    [customkey: string]: string;
+}
+export interface CustomWindow extends Window {
+    __env__?: HortiViewEnvironments;
+}
+export type Environments = 'SDC-DEV' | 'SDC-TEST' | 'SDC-DEMO' | 'BAYER-TES' | 'BAYER-DEM' | 'BAYER-STAG' | 'BAYER-PROD';
+export type EnvConfig = {
+    [key in Environments]?: CustomEnv;
+};
+export type CustomEnv = {
+    [key: string]: string;
+};

package/dist/lib/types/EnvironmentVariable.d.ts

@@ -0,0 +1,6 @@
+export type EnvironmentVariable = {
+    id?: string;
+    key: string;
+    value: string;
+    appEnvironmentId: string | null;
+};

package/dist/lib/types/ModuleApi.d.ts

@@ -0,0 +1,163 @@
+export type RegisterOption = {
+    moduleId: string;
+    registeredEntityName: string;
+    id: string;
+};
+export interface ModuleEntity {
+    season: Season | undefined;
+    blockPlantLayout: BlockPlantLayout | undefined;
+}
+/**
+ * the basic interface for the module apis farm organization entities
+ */
+export interface FarmOrgEntity {
+    block: Block | undefined;
+    farm: Farm | undefined;
+    field: Field | undefined;
+    farmOrg: {
+        id: string;
+    } | undefined;
+    irrigationStation: {
+        id: string;
+    } | undefined;
+    farmAlertRule: {
+        id: string;
+    } | undefined;
+    id: string;
+}
+export interface FarmOrganization {
+    parentOrganizationId: string | null;
+    organizationName: string;
+    legalForm: string | null;
+    primaryContactId: string;
+    secondaryContactId: string | null;
+    creatorId: string;
+    addressId: string;
+    ownerId: string;
+    description: string | null;
+    address: Address;
+    id: string;
+}
+export type Block = {
+    id: string;
+    fieldId: string;
+    blockName?: string;
+    shortName?: string;
+    area?: number;
+    fieldPercentage?: number;
+    description?: string;
+    length?: number;
+    width?: number;
+    rows?: number;
+    /** Stringyfied Position, only used in BE */
+    location?: string;
+    /**Position will be transformed from the Location string, only internally used*/
+    position?: {
+        row: number;
+        column: number;
+    };
+};
+/**
+ * farm dto (only necessary fields - for now)
+ */
+export interface Farm {
+    id: string;
+    farmName: string;
+    description: string;
+    fields: Field[];
+    longitude: number;
+    latitude: number;
+    organizationId: string;
+    location: string;
+    primaryContactId: string;
+    secondaryContactId: string;
+    address: Address;
+}
+export interface Field {
+    farmId: string;
+    name: string;
+    description: string;
+    fieldTechnologyTypeId: string;
+    fieldCoverageTypeId: string;
+    fieldShadingTypeId: string;
+    fieldSowingTypeId: string;
+    fieldSubstrateTypeId: string;
+    length: number | null;
+    width: number | null;
+    rows: number | null;
+    location: string;
+    area: number;
+    tag: string | null;
+    fieldTypeId: string;
+    id: string;
+}
+export interface Season {
+    id: string;
+    cropSeasonName: string;
+    startDate: Date;
+    plantingDate: Date | null;
+    cropId: string;
+    cropTypeId: string;
+    cropVarietyId: string;
+    rootstockId: string;
+    farmId: string;
+    fieldId: string;
+    seasonStateId?: string;
+}
+export interface BlockPlantLayout {
+    id: string;
+    blockId: string;
+    arrangementType: string | null;
+    offsetPlants: number;
+    offsetPlantsUnit: string;
+    rowLength: number;
+    rowLengthUnit: string;
+    offsetRows: number;
+    offsetRowsUnit: string;
+    numberOfRows: number;
+    numberOfPlants: number;
+}
+export interface IrrigationStation {
+    irrigationStationName: string;
+    farmId: string;
+    totalArea: number;
+    totalAreaUnit: string;
+    flow: number;
+    flowUnit: string;
+    irrigationZoneFields: IrrigationZoneField[];
+    id: string;
+}
+export interface FarmAlertRule {
+    farmOrganizationId: string;
+    moduleId: string;
+    farmId: string;
+    description: string;
+    descriptionTranslationsAsJson: string;
+    raisesNotification: boolean;
+    ruleAsJson: string;
+    recipients: string[];
+    id: string;
+}
+interface IrrigationZoneField {
+    fieldId: string;
+    irrigationZoneFieldBlocks: IrrigationZoneFieldBlock[];
+    id: string;
+}
+interface IrrigationZoneFieldBlock {
+    blockId: string;
+    id: string;
+}
+interface Address {
+    addressLine1: string;
+    addressLine2: string | null;
+    addressLine3: string | null;
+    directions: string | null;
+    city: string;
+    postalCode: string;
+    state: string;
+    countryId: string;
+    longitude: number;
+    latitude: number;
+    id: string;
+}
+export {};

package/dist/lib/types/Requests.d.ts

@@ -0,0 +1,44 @@
+import { Expand, Filter, Select } from 'odata-query';
+export type RequestConfig = {
+    redirect: 'follow';
+    credentials: 'omit';
+    headers: RequestHeader;
+    method: httpMethod;
+    body?: string | FormData;
+};
+export type RequestHeader = Headers & {
+    'Content-Type'?: 'application/json';
+    orgId?: string;
+    Authorization?: string;
+    Permission?: string;
+    'Api-Version'?: '1.0' | '2.0';
+    languageId?: string;
+};
+export type InternalError = {
+    status: number;
+    title: string;
+    detail: string;
+    stack?: string;
+};
+export type Query = {
+    filter?: Filter<unknown>;
+    orderBy?: string[];
+    expand?: string | string[] | Expand<unknown>;
+    select?: Select<unknown>;
+    count?: boolean | Filter<unknown>;
+    pagination?: Pagination;
+    top?: number;
+    skip?: number;
+    overwrite?: string;
+};
+export type Pagination = {
+    top?: number;
+    skip?: number;
+    pageSize?: number;
+};
+export type BaseResponse<T> = T | T[] | {
+    value: T | T[];
+} | {
+    items: T | T[];
+};
+export type httpMethod = 'POST' | 'PATCH' | 'DELETE' | 'PUT' | 'GET';

package/dist/lib/types/ServiceBus.d.ts

@@ -0,0 +1,17 @@
+export type AlertServiceBusMessage = {
+    farmOrganizationId: string;
+    alertRulesDefinitionId: string;
+    farmId: string;
+    fieldId: string;
+    blockId: string;
+    /**
+     * needs to be an ID that can be received from the common data/api
+     */
+    criteriaId: string;
+    moduleId: string;
+    description: string;
+};
+export type ServiceBusMessage = AlertServiceBusMessage & {
+    deviceId: '62ac8dbc-45bc-407d-9fb4-8efe9747abe0';
+    scope: 'FarmOrgMembers';
+};

package/dist/lib/types/SystemMessage.d.ts

@@ -0,0 +1,14 @@
+export type SystemMessage = {
+    id: string;
+    title: string;
+    description: string | JSX.Element;
+    timeStamp: string | Date;
+    isRead: boolean;
+    isSnoozed: boolean;
+    icon?: {
+        name: string;
+        danger?: boolean;
+    };
+    link?: string;
+    action?: () => void;
+};

package/dist/lib/utils/api.d.ts

@@ -0,0 +1,20 @@
+import { BaseResponse, httpMethod, Query, RequestConfig } from '../types/Requests';
+export declare const getConfig: (token?: string, organizationId?: string, languageId?: string, method?: httpMethod, customHeaders?: Headers) => RequestConfig;
+/**
+ * a fetch function to handle requests and returns the response. if the response is unauthorized, it tries to refresh the token and retries the request
+ * @param url - the complete url build by {@link prependBaseUrl}
+ * @param config - the request config including auth headers
+ * @param throwFullMessage - if the full error message should be thrown or only the message behind the status code
+ * @param withResponseHandling - if the response should be handled by the {@link handleResponse} method or not ("hide" the error)
+ * @param tries - the number of retries, default is 1
+ * @returns
+ */
+export declare const fetchWithErrorHandling: <T>(url: string, config: RequestConfig, tries?: number, withResponseHandling?: boolean) => Promise<BaseResponse<T>>;
+export declare const handleResponse: (response: Response) => Promise<any>;
+/**
+ * a helper function to format the query string
+ * @param query - the query object to format
+ * @param withApiVersion - if the api version should be added to the query string
+ * @returns
+ */
+export declare const formatQuery: (query?: Query, withApiVersion?: boolean) => string;

package/dist/lib/utils/baseFetches.d.ts

@@ -0,0 +1,19 @@
+import { BaseResponse, httpMethod, Query } from '../types/Requests';
+/**
+ * a fetch function to handle CUD requests and returns the response.
+ * @param url endpoint to fetch (CUD) data from
+ * @param data data to send
+ * @param method method to use (POST, PUT, DELETE, PATCH)
+ * @param customToken token to use (default is the modulePermissionToken)
+ * @param headers (optional) custom headers to use
+ * @returns Promise<BaseResponse<R>> response from the fetch
+ */
+export declare const baseMutation: <T, R>(url: string, data: T, method: Omit<httpMethod, "GET">, customToken?: string, headers?: Headers, noAuth?: boolean) => Promise<BaseResponse<R>>;
+/**
+ * a fetch function to handle GET requests and returns the response.
+ * @param url url to GET data from
+ * @param query query to use for the GET request
+ * @param customToken token to use (default is the modulePermissionToken)
+ * @returns Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const baseFetch: <T>(url: string, query: Query, customToken?: string, noAuth?: boolean) => Promise<BaseResponse<T>>;

package/dist/lib/utils/fetches.d.ts

@@ -0,0 +1,43 @@
+import { httpMethod } from '../types/Requests';
+export declare const mutateOnCustomApi: <T, R>(endpoint: string, data: T, method?: Omit<httpMethod, "GET">, token?: string, headers?: Headers, noAuth?: boolean) => Promise<import('../main').BaseResponse<R>>;
+/**
+ * a fetch function to get a certain farmorganization entity from the moduleApi (will be used in useEntity)
+ * @param moduleId moduleID to get the entity from
+ * @param entityId entityID of the entity to get
+ * @returns entity to get
+ */
+export declare const getFarmOrgEntities: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ * a fetch function to get a certain MODULEDEPENDED entity from the moduleApi (will be used in useEntity)
+ * @param moduleId moduleID to get the entity from
+ * @param entityId entityID of the entity to get
+ * @returns entity to get
+ */
+export declare const getModuleDependedEntities: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ * a fetch function to get a certain MODULEDEPENDED entity from the moduleApi (will be used in useEntity)
+ * the data will be returned in a raw format
+ * @param moduleId
+ * @param entityId
+ * @returns
+ */
+export declare const getModuleDependedEntitiesRaw: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint custom endpoint to GET data from
+ * @param token token to use (default is the modulePermissionToken)
+ * @returns Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromCustomApi: <T>(endpoint: string, token?: string, noAuth?: boolean) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint endpoint of moduleApi to fetch data from
+ * @returns  Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromModuleApi: <T>(endpoint: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint endpoint of commonApi to fetch data from
+ * @returns  Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromCommonApi: <T>(endpoint: string) => Promise<import('../main').BaseResponse<T>>;

package/dist/lib/utils/helper.d.ts

@@ -0,0 +1,29 @@
+import { BaseProps } from '../main';
+import { EnvConfig, Environments, HortiViewEnvironments } from '../types/Environment';
+import { BaseResponse } from '../types/Requests';
+/**
+ * Validates the props and checks if the required props are set
+ * @param props props to be validated
+ * @param requiredProps props that will be validated/checked if they exist
+ */
+export declare const arePropsValid: (props: BaseProps) => boolean;
+/**
+ * Checks if a prop exists and throws an error if it does not
+ * @param prop prop to be checked
+ * @param props props to be checked against
+ */
+export declare const checkIfPropExists: (prop: keyof BaseProps, props: BaseProps) => boolean;
+/**
+ * check if hortiview return the __env__ object correctly
+ * @returns the environment variables from the window object
+ */
+export declare const getEnvironmentVariables: () => HortiViewEnvironments | undefined;
+export declare const checkVersion: (environmentVariables?: HortiViewEnvironments) => string | null;
+/**
+ * a universal selector that can be used for all fetches
+ * @param data - the data to select from
+ * @returns
+ */
+export declare const universalSelector: <T>(data: BaseResponse<T>) => T | T[];
+export declare const checkConfig: <T extends EnvConfig>(config: T & Record<Exclude<keyof T, Environments>, never>) => T;
+export declare const getModuleQueryKey: (queryKey: (string | undefined)[]) => (string | undefined)[];

package/dist/main.js

@@ -0,0 +1,218 @@
+import { ModuleBase as A } from "./components/ModuleBase.js";
+import { i as f, h as m, b as l } from "./ModuleCore-YCIFN_02.js";
+import { M as C, Q as U } from "./ModuleCore-YCIFN_02.js";
+import { useBreadcrumbTranslation as M } from "./hooks/useBreadcrumbTranslation.js";
+import { useOffline as k } from "./hooks/useOffline.js";
+import { useSignalRMessages as L } from "./hooks/useSignalRMessages.js";
+import { useNavigate as B } from "./module-router.js";
+import { useBaseProps as H, useConfig as Q } from "./hooks/useStores.js";
+import { useCustom as T } from "./hooks/useCustom.js";
+import { useCustomMutation as K } from "./hooks/useCustomMutation.js";
+import { useEntity as G } from "./hooks/useEntity.js";
+import { useOption as j } from "./hooks/useOption.js";
+import { useNotification as J, useServiceBus as X } from "./hooks/useServiceBus.js";
+import { mutateOnCustomApi as Z } from "./utils/fetches.js";
+import { arePropsValid as ee, checkConfig as ae, checkIfPropExists as se, checkVersion as te, getEnvironmentVariables as re, getModuleQueryKey as oe, universalSelector as ie } from "./utils/helper.js";
+import { Q as g, a as d } from "./useQuery-Bj9k9zik.js";
+import { u as ne } from "./useQuery-Bj9k9zik.js";
+import { u as he } from "./useMutation-zu8uxBak.js";
+import { u as Se } from "./QueryClientProvider-Beog9TR7.js";
+import { A as me, B as le, F as ge, H as de, I as Ee, a as Pe, b as pe, L as Ne, c as Fe, M as xe, d as ve, N as Ae, e as _e, f as Ce, O as Ue, P as ye, R as Me, g as be, h as ke, i as Oe, S as Le, j as we, k as Be, l as De, m as He, D as Qe, n as Ie, E as Te, o as Ve, p as Ke, q as ze, r as Ge, s as We, t as je, u as qe, v as Je, V as Xe, w as Ye, x as Ze, y as $e, z as ea, C as aa, G as sa, J as ta, K as ra, Q as oa, T as ia, U as ua, W as na, X as ca, Y as ha, Z as fa, _ as Sa, $ as Ra, a0 as ma, a1 as la, a2 as ga, a3 as da, a4 as Ea, a5 as Pa, a6 as pa, a7 as Na, a8 as Fa, a9 as xa, aa as va, ab as Aa, ac as _a, ad as Ca, ae as Ua, af as ya, ag as Ma, ah as ba, ai as ka, aj as Oa, ak as La, al as wa, am as Ba, an as Da, ao as Ha, ap as Qa, aq as Ia, ar as Ta, as as Va, at as Ka, au as za, av as Ga, aw as Wa, ax as ja, ay as qa, az as Ja, aA as Xa, aB as Ya, aC as Za, aD as $a, aE as es, aF as as, aG as ss, aH as ts, aI as rs, aJ as os, aK as is, aL as us, aM as ns, aN as cs, aO as hs, aP as fs, aQ as Ss, aR as Rs, aS as ms, aT as ls } from "./chunk-IR6S3I6Y-BmDdD3SP.js";
+var E = class extends g {
+  constructor(e, a) {
+    super(e, a);
+  }
+  bindMethods() {
+    super.bindMethods(), this.fetchNextPage = this.fetchNextPage.bind(this), this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+  }
+  setOptions(e, a) {
+    super.setOptions(
+      {
+        ...e,
+        behavior: f()
+      },
+      a
+    );
+  }
+  getOptimisticResult(e) {
+    return e.behavior = f(), super.getOptimisticResult(e);
+  }
+  fetchNextPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "forward" }
+      }
+    });
+  }
+  fetchPreviousPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "backward" }
+      }
+    });
+  }
+  createResult(e, a) {
+    const { state: t } = e, r = super.createResult(e, a), { isFetching: o, isRefetching: S, isError: i, isRefetchError: R } = r, s = t.fetchMeta?.fetchMore?.direction, u = i && s === "forward", n = o && s === "forward", c = i && s === "backward", h = o && s === "backward";
+    return {
+      ...r,
+      fetchNextPage: this.fetchNextPage,
+      fetchPreviousPage: this.fetchPreviousPage,
+      hasNextPage: m(a, t.data),
+      hasPreviousPage: l(a, t.data),
+      isFetchNextPageError: u,
+      isFetchingNextPage: n,
+      isFetchPreviousPageError: c,
+      isFetchingPreviousPage: h,
+      isRefetchError: R && !u && !c,
+      isRefetching: S && !n && !h
+    };
+  }
+};
+function F(e, a) {
+  return d(
+    e,
+    E,
+    a
+  );
+}
+export {
+  me as Await,
+  le as BrowserRouter,
+  ge as Form,
+  de as HashRouter,
+  Ee as IDLE_BLOCKER,
+  Pe as IDLE_FETCHER,
+  pe as IDLE_NAVIGATION,
+  Ne as Link,
+  Fe as Links,
+  xe as MemoryRouter,
+  ve as Meta,
+  A as ModuleBase,
+  C as ModuleCore,
+  Ae as NavLink,
+  _e as Navigate,
+  Ce as NavigationType,
+  Ue as Outlet,
+  ye as PrefetchPageLinks,
+  U as QueryClient,
+  Me as Route,
+  be as Router,
+  ke as RouterProvider,
+  Oe as Routes,
+  Le as Scripts,
+  we as ScrollRestoration,
+  Be as ServerRouter,
+  De as StaticRouter,
+  He as StaticRouterProvider,
+  Qe as UNSAFE_DataRouterContext,
+  Ie as UNSAFE_DataRouterStateContext,
+  Te as UNSAFE_ErrorResponseImpl,
+  Ve as UNSAFE_FetchersContext,
+  Ke as UNSAFE_FrameworkContext,
+  ze as UNSAFE_LocationContext,
+  Ge as UNSAFE_NavigationContext,
+  We as UNSAFE_RemixErrorBoundary,
+  je as UNSAFE_RouteContext,
+  qe as UNSAFE_ServerMode,
+  Je as UNSAFE_SingleFetchRedirectSymbol,
+  Xe as UNSAFE_ViewTransitionContext,
+  Ye as UNSAFE_createBrowserHistory,
+  Ze as UNSAFE_createClientRoutes,
+  $e as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
+  ea as UNSAFE_createRouter,
+  aa as UNSAFE_decodeViaTurboStream,
+  sa as UNSAFE_deserializeErrors,
+  ta as UNSAFE_getPatchRoutesOnNavigationFunction,
+  ra as UNSAFE_getSingleFetchDataStrategy,
+  oa as UNSAFE_invariant,
+  ia as UNSAFE_mapRouteProperties,
+  ua as UNSAFE_shouldHydrateRouteLoader,
+  na as UNSAFE_useFogOFWarDiscovery,
+  ca as UNSAFE_useScrollRestoration,
+  ee as arePropsValid,
+  ae as checkConfig,
+  se as checkIfPropExists,
+  te as checkVersion,
+  ha as createBrowserRouter,
+  fa as createCookie,
+  Sa as createCookieSessionStorage,
+  Ra as createHashRouter,
+  ma as createMemoryRouter,
+  la as createMemorySessionStorage,
+  ga as createPath,
+  da as createRequestHandler,
+  Ea as createRoutesFromChildren,
+  Pa as createRoutesFromElements,
+  pa as createRoutesStub,
+  Na as createSearchParams,
+  Fa as createSession,
+  xa as createSessionStorage,
+  va as createStaticHandler,
+  Aa as createStaticRouter,
+  _a as data,
+  Ca as generatePath,
+  re as getEnvironmentVariables,
+  oe as getModuleQueryKey,
+  Ua as isCookie,
+  ya as isRouteErrorResponse,
+  Ma as isSession,
+  ba as matchPath,
+  ka as matchRoutes,
+  Z as mutateOnCustomApi,
+  Oa as parsePath,
+  La as redirect,
+  wa as redirectDocument,
+  Ba as renderMatches,
+  Da as replace,
+  Ha as resolvePath,
+  ie as universalSelector,
+  Qa as unstable_HistoryRouter,
+  Ia as unstable_setDevServerHooks,
+  Ta as unstable_usePrompt,
+  Va as useActionData,
+  Ka as useAsyncError,
+  za as useAsyncValue,
+  H as useBaseProps,
+  Ga as useBeforeUnload,
+  Wa as useBlocker,
+  M as useBreadcrumbTranslation,
+  Q as useConfig,
+  T as useCustom,
+  K as useCustomMutation,
+  G as useEntity,
+  ja as useFetcher,
+  qa as useFetchers,
+  Ja as useFormAction,
+  Xa as useHref,
+  Ya as useInRouterContext,
+  F as useInfiniteQuery,
+  Za as useLinkClickHandler,
+  $a as useLoaderData,
+  es as useLocation,
+  as as useMatch,
+  ss as useMatches,
+  he as useMutation,
+  B as useNavigate,
+  ts as useNavigation,
+  rs as useNavigationType,
+  J as useNotification,
+  k as useOffline,
+  j as useOption,
+  os as useOutlet,
+  is as useOutletContext,
+  us as useParams,
+  ne as useQuery,
+  Se as useQueryClient,
+  ns as useResolvedPath,
+  cs as useRevalidator,
+  hs as useRouteError,
+  fs as useRouteLoaderData,
+  Ss as useRoutes,
+  Rs as useSearchParams,
+  X as useServiceBus,
+  L as useSignalRMessages,
+  ms as useSubmit,
+  ls as useViewTransitionState
+};