@hortiview/modulebase 0.0.1-7.1-beta

package/dist/lib/constants.d.ts

@@ -0,0 +1,25 @@
+import { BaseProps } from './types/BaseProps';
+export declare const REQUIRED_PROPS: (keyof BaseProps)[];
+export declare const RETRIES = 1;
+export declare const RETRY_HTTP_STATUS_CODES: {
+    /**
+     * The server timed out waiting for the request.
+     */
+    RequestTimeout: number;
+    /**
+     * The user has sent too many requests in a given amount of time ("rate limiting").
+     */
+    TooManyRequests: number;
+    /**
+     * The server is not ready to handle the request.
+     */
+    BadGateway: number;
+    /**
+     * The server is not available.
+     */
+    ServiceUnavailable: number;
+    /**
+     * The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
+     */
+    GatewayTimeout: number;
+};

package/dist/lib/hooks/useBreadcrumbTranslation.d.ts

@@ -0,0 +1 @@
+export declare const useBreadcrumbTranslation: () => (key: string, value: string | false) => void;

package/dist/lib/hooks/useCustom.d.ts

@@ -0,0 +1,8 @@
+export declare const useCustom: <T>({ endpoint, queryKey, token, selector, enabled, noAuth }: {
+    endpoint: string;
+    queryKey: (string | undefined)[];
+    token?: string;
+    selector?: (data: any) => T;
+    enabled?: boolean;
+    noAuth?: boolean;
+}) => import('@tanstack/react-query').UseQueryResult<T, Error>;

package/dist/lib/hooks/useCustomMutation.d.ts

@@ -0,0 +1,9 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { BaseResponse, httpMethod } from '../types/Requests';
+export declare const useCustomMutation: <Input, Output>({ endpoint, method, token, headers, noAuth }: {
+    endpoint: string;
+    method: Omit<httpMethod, "GET">;
+    token?: string;
+    headers?: Headers;
+    noAuth?: boolean;
+}) => UseMutationResult<BaseResponse<Output>, Error, Input, unknown>;

package/dist/lib/hooks/useEntity.d.ts

@@ -0,0 +1,162 @@
+import { FarmOrgEntity, ModuleEntity } from '../types/ModuleApi';
+import { HortiviewDataAreaEntity, HortiviewDataAreaGroup, ModuleDataAreaGroup, ResultMap } from '../types/Entities';
+export declare const useEntity: <K extends HortiviewDataAreaGroup | ModuleDataAreaGroup, E extends HortiviewDataAreaEntity<K>>(group: K, entity: E, enabled?: boolean, shouldGetRawData?: boolean) => {
+    data: ResultMap<E>[];
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+} | {
+    data: ResultMap<E>[];
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+} | {
+    data: ResultMap<E>[];
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+} | {
+    data: ResultMap<E>[];
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+} | {
+    data: ResultMap<E>[];
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+} | {
+    data: ResultMap<E>[];
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import('@tanstack/query-core').RefetchOptions) => Promise<import('@tanstack/query-core').QueryObserverResult<FarmOrgEntity[] | ModuleEntity[], Error>>;
+    fetchStatus: import('@tanstack/query-core').FetchStatus;
+    promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
+};
+export declare const useEntityId: (group: HortiviewDataAreaGroup | ModuleDataAreaGroup) => {
+    getEntityId: (entity: HortiviewDataAreaEntity<typeof group>) => string | undefined;
+};

package/dist/lib/hooks/useOffline.d.ts

@@ -0,0 +1,15 @@
+import { HortiviewDataAreaEntity, HortiviewDataAreaGroup, ModuleDataAreaGroup } from '../types/Entities';
+export declare const useOffline: () => {
+    prefetchCustom: <T>({ queryKey, endpoint, token, noAuth, }: {
+        queryKey: (string | undefined)[];
+        endpoint: string;
+        token?: string;
+        noAuth?: boolean;
+        selector?: (data: any) => T;
+    }) => Promise<void>;
+    prefetch: <T>({ queryKey, queryFn, }: {
+        queryKey: (string | undefined)[];
+        queryFn: () => Promise<T>;
+    }) => Promise<void>;
+    usePrefetchEntity: <K extends HortiviewDataAreaGroup | ModuleDataAreaGroup, E extends HortiviewDataAreaEntity<K>>(group: K, ...entities: E[]) => "Prefetch failed: no moduleId" | undefined;
+};

package/dist/lib/hooks/useOption.d.ts

@@ -0,0 +1,17 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { CommonOption, CommonOptionType } from '../types/CommonOptions';
+import { RegisterOption } from '../types/ModuleApi';
+/**
+ * Custom hook to fetch and manage options for a dropdown.
+ *
+ * @param dropdown - The key of the dropdown option to fetch from the common options.
+ * @returns A query object from `useQuery` containing the fetched dropdown options.
+ *
+ * This hook first attempts to retrieve the dropdown options from the HortiView-platform (module-property `commonOptions`).
+ * If the options are not available locally, it fetches them from a common API endpoint.
+ *
+ * The query key is set to the dropdown key, and the query function either resolves the local option
+ * or fetches it from the API. The result is then processed by a universal selector.
+ */
+export declare const useOption: (dropdown: keyof typeof CommonOptionType) => UseQueryResult<CommonOption[], Error>;
+export declare const useModuleDependency: (enabled?: boolean) => UseQueryResult<RegisterOption[], Error>;

package/dist/lib/hooks/useServiceBus.d.ts

@@ -0,0 +1,19 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { BaseResponse } from '../types/Requests';
+import { AlertServiceBusMessage } from '../types/ServiceBus';
+/**
+ *
+ * @param authenticationKey SASToken, that will be provided by the vendor portal of HortiView
+ * @param queue url of the service bus queue
+ * @param topic topic of the service bus, where the message will be sent to
+ * @deprecated use useNotification instead
+ */
+export declare const useServiceBus: ({ authenticationKey, queue, topic, }: {
+    authenticationKey: string;
+    queue: string;
+    topic: string;
+}) => UseMutationResult<BaseResponse<unknown>, Error, AlertServiceBusMessage, unknown>;
+/**
+ * create a notification in the service bus
+ */
+export declare const useNotification: () => UseMutationResult<BaseResponse<unknown>, Error, AlertServiceBusMessage, unknown>;

package/dist/lib/hooks/useSignalRMessages.d.ts

@@ -0,0 +1,6 @@
+import { SignalRMessage } from '../provider/SignalR/signalR';
+/**
+ * hook to react on messages from signalR
+ * @param callback callback function to be called when a message is received
+ */
+export declare const useSignalRMessages: (callback: (message: SignalRMessage) => void) => void;

package/dist/lib/hooks/useStores.d.ts

@@ -0,0 +1,37 @@
+export declare const useBaseProps: () => Pick<import('../main').DeprecatedBaseProps & {
+    isOnline?: boolean;
+    modulePermissionToken?: string;
+    moduleId?: string;
+    organizationId?: string;
+    basePath?: string;
+    currentNavigationPath?: string;
+    sourcePath?: string | null;
+    currentLanguage?: string;
+    currentLanguageId?: string;
+    alertRules?: string;
+    commonOptions?: import('../main').AllDropdownsData<import('../main').CommonOption>["items"];
+    riseNotification?: (message: import('../main').AlertServiceBusMessage) => Promise<unknown>;
+    navigateInHortiview?: (path: string) => void;
+    addBreadcrumbTranslation?: (translation: {
+        key: string;
+        value: string;
+    }, hide?: boolean) => void;
+    showSnackbar?: (message: string, icon?: string) => void;
+    showMessage?: (message: import('../main').SystemMessage) => void;
+    pendingActions?: import('../main').ActionItem[];
+    resolveAction?: (key: string, result?: string) => void;
+    addAction?: (functionName: string, args: unknown[], key?: string) => void;
+    getActions?: () => import('../main').ActionItem[];
+    getActionByKey?: (key: string) => import('../main').ActionItem | undefined;
+    logEvent?: (event: import('../main').AppInsightsEvent, customProperties?: import('../main').AppInsightsProperties) => void;
+    logError?: (exception: import('../main').AppInsightsException) => void;
+    throwError?: (message: string, code: number) => void;
+    environmentVariables?: import('../main').EnvironmentVariable[];
+} & {
+    setBaseProps: (props: import('../main').BaseProps) => void;
+}, keyof import('../main').DeprecatedBaseProps | "isOnline" | "modulePermissionToken" | "moduleId" | "organizationId" | "basePath" | "currentNavigationPath" | "sourcePath" | "currentLanguage" | "currentLanguageId" | "alertRules" | "commonOptions" | "riseNotification" | "navigateInHortiview" | "addBreadcrumbTranslation" | "showSnackbar" | "showMessage" | "pendingActions" | "resolveAction" | "addAction" | "getActions" | "getActionByKey" | "logEvent" | "logError" | "throwError" | "environmentVariables">;
+export declare const useConfig: () => Pick<{
+    environment: import('../main').HortiViewEnvironments;
+    setEnvironment: (environment: import('../main').HortiViewEnvironments) => void;
+    addEnvironment: (customEnv: import('../main').CustomEnv) => void;
+}, "environment">;

package/dist/lib/main.d.ts

@@ -0,0 +1,27 @@
+export { ModuleBase } from './components/ModuleBase';
+export { ModuleCore } from './components/ModuleCore';
+export type * from './types/AppInsights';
+export type * from './types/BaseProps';
+export type * from './types/CommonOptions';
+export type * from './types/Deprecated';
+export type * from './types/Environment';
+export type * from './types/EnvironmentVariable';
+export type * from './types/ModuleApi';
+export type * from './types/Requests';
+export type * from './types/ServiceBus';
+export type * from './types/SystemMessage';
+export type * from './types/ActionStorage';
+export { useBreadcrumbTranslation } from './hooks/useBreadcrumbTranslation';
+export { useOffline } from './hooks/useOffline';
+export { useSignalRMessages } from './hooks/useSignalRMessages';
+export * from './module-router';
+export { useNavigate } from './module-router';
+export { useBaseProps, useConfig } from './hooks/useStores';
+export { useCustom } from './hooks/useCustom';
+export { useCustomMutation } from './hooks/useCustomMutation';
+export { useEntity } from './hooks/useEntity';
+export { useOption } from './hooks/useOption';
+export { useNotification, useServiceBus } from './hooks/useServiceBus';
+export { QueryClient, useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+export { mutateOnCustomApi } from './utils/fetches';
+export * from './utils/helper';

package/dist/lib/module-router.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @returns A function to navigate to a specific path
+ */
+declare const useNavigate: () => (path: string) => void;
+export * from 'react-router';
+export { useNavigate };

package/dist/lib/provider/SignalR/SignalRProvider.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from 'react';
+/**
+ * SignalRProvider on behalf of the module
+ */
+export declare const SignalRModuleContext: import('react-signalr/lib/signalr/types').Context<import('react-signalr/lib/signalr/types').Hub<string, string>>;
+/**
+ * SignalRProvider
+ * @param children
+ * @returns
+ */
+export declare const SignalRProvider: ({ children, enabled, }: PropsWithChildren & {
+    enabled: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/provider/SignalR/signalR.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SignalR message interface, contains property bag for additional data
+ */
+export interface SignalRMessage {
+    messageId: string;
+    messageType: keyof typeof MessageType;
+    entityId: string;
+    entityType: keyof typeof EntityType;
+    operationType: keyof typeof OperationType;
+    message: string;
+    propertyBag: PropertyBag;
+}
+/**
+ * Property bag interface
+ * Contains key value pairs with additional data, cant be different for each message
+ */
+interface PropertyBag extends Record<string, string> {
+}
+/**
+ * Enum for the possible operation types
+ */
+export declare enum OperationType {
+    Create = "Create",
+    Read = "Read",
+    Update = "Update",
+    Delete = "Delete"
+}
+/**
+ * Enum for the possible message types
+ * currently not in use
+ */
+export declare enum MessageType {
+    Notification = "Notification",
+    Alert = "Alert"
+}
+/**
+ * Enum for the possible entity types
+ * the entity type is used to determine the target of the message
+ * please check which kind of entity types are available in the platform and add them here
+ * of course you can add more entity types if needed for your module
+ */
+export declare enum EntityType {
+    Block = "Block",
+    Field = "Field"
+}
+/**
+ * the mapping list of notification icons for the different entity types
+ * the icon is used to display the notification in the notification center
+ * please check which icons are available in the platform and add them here
+ * of course you can add more icons if needed for your module
+ */
+export declare const NotificationIcons: Record<keyof typeof EntityType, string>;
+export {};

package/dist/lib/stores/BasePropsStore.d.ts

@@ -0,0 +1,6 @@
+import { BaseProps } from '../types/BaseProps';
+type BasePropsStore = BaseProps & {
+    setBaseProps: (props: BaseProps) => void;
+};
+export declare const useBasePropsStore: import('zustand/react').UseBoundStore<import('zustand/vanilla').StoreApi<BasePropsStore>>;
+export {};

package/dist/lib/stores/EnvironmentStore.d.ts

@@ -0,0 +1,8 @@
+import { CustomEnv, HortiViewEnvironments } from '../types/Environment';
+type EnvironmentStore = {
+    environment: HortiViewEnvironments;
+    setEnvironment: (environment: HortiViewEnvironments) => void;
+    addEnvironment: (customEnv: CustomEnv) => void;
+};
+export declare const useEnvironmentStore: import('zustand/react').UseBoundStore<import('zustand/vanilla').StoreApi<EnvironmentStore>>;
+export {};

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

@@ -0,0 +1,12 @@
+export declare enum ActionState {
+    PENDING = "PENDING",
+    SUCCESS = "RESOLVED",
+    ERROR = "REJECTED"
+}
+export type ActionItem = {
+    functionName: string;
+    args: unknown[];
+    dateAdded: string;
+    state: ActionState;
+    key: string;
+};

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

@@ -0,0 +1,12 @@
+export type AppInsightsEvent = {
+    name: string;
+    properties?: AppInsightsProperties;
+};
+export type AppInsightsException = {
+    id?: string;
+    exception: Error;
+    properties?: AppInsightsProperties;
+};
+export type AppInsightsProperties = {
+    [key: string]: unknown;
+};

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

@@ -0,0 +1,49 @@
+import { ActionItem } from './ActionStorage';
+import { AppInsightsEvent, AppInsightsException, AppInsightsProperties } from './AppInsights';
+import { AllDropdownsData, CommonOption } from './CommonOptions';
+import { DeprecatedBaseProps } from './Deprecated';
+import { EnvironmentVariable } from './EnvironmentVariable';
+import { AlertServiceBusMessage } from './ServiceBus';
+import { SystemMessage } from './SystemMessage';
+/**
+ * Properties that are passed to the Base component by the host application
+ * @param token authentication user token
+ * @param modulePermissionToken token for the module, to communicate with the module api
+ * @param moduleId id of the module
+ * @param basePath base path of the module (that is part of the URL and will be used for routing)
+ * @param organizationId id of the organization, where the module is used
+ * @param config configuration object that is used to configure the module
+ * @param navigateTo function to navigate to a specific route to trigger the routing in the host application
+ * @param addTranslation function to add a translation to the i18n instance of the host application
+ * @param currentNavigationPath current path of the route, that is changed, when the host application navigates
+ */
+export type BaseProps = DeprecatedBaseProps & {
+    isOnline?: boolean;
+    modulePermissionToken?: string;
+    moduleId?: string;
+    organizationId?: string;
+    basePath?: string;
+    currentNavigationPath?: string;
+    sourcePath?: string | null;
+    currentLanguage?: string;
+    currentLanguageId?: string;
+    alertRules?: string;
+    commonOptions?: AllDropdownsData<CommonOption>['items'];
+    riseNotification?: (message: AlertServiceBusMessage) => Promise<unknown>;
+    navigateInHortiview?: (path: string) => void;
+    addBreadcrumbTranslation?: (translation: {
+        key: string;
+        value: string;
+    }, hide?: boolean) => void;
+    showSnackbar?: (message: string, icon?: string) => void;
+    showMessage?: (message: SystemMessage) => void;
+    pendingActions?: ActionItem[];
+    resolveAction?: (key: string, result?: string) => void;
+    addAction?: (functionName: string, args: unknown[], key?: string) => void;
+    getActions?: () => ActionItem[];
+    getActionByKey?: (key: string) => ActionItem | undefined;
+    logEvent?: (event: AppInsightsEvent, customProperties?: AppInsightsProperties) => void;
+    logError?: (exception: AppInsightsException) => void;
+    throwError?: (message: string, code: number) => void;
+    environmentVariables?: EnvironmentVariable[];
+};

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

@@ -0,0 +1,61 @@
+export interface CommonOption {
+    id: string;
+    value?: string;
+    description?: string;
+    key?: string;
+    parent?: string;
+    icon?: string;
+}
+export interface CommonOptionOdata extends DropdownData<CommonOption> {
+}
+export interface AllCommonOptionsOdata extends AllDropdownsData<CommonOption> {
+}
+export interface AllDropdownsData<T> {
+    count: number;
+    totalCount: number;
+    items: Partial<Record<keyof typeof CommonOptionType, T[]>>;
+}
+export interface DropdownData<T> {
+    count: number;
+    totalCount: number;
+    items: T[];
+}
+export declare enum CommonOptionType {
+    Category = 0,
+    Requirement = 1,
+    Country = 2,
+    CountryCode = 3,
+    Crop = 4,
+    CropType = 5,
+    CropVariety = 6,
+    Currency = 7,
+    DataAreaEntity = 8,
+    DataAreaGroup = 9,
+    FieldAutomationLevelType = 10,
+    FieldCoverageType = 11,
+    FieldSecurityLevelType = 12,
+    FieldShadingType = 13,
+    FieldSowingType = 14,
+    FieldSubstrateType = 15,
+    FieldTechnologyType = 16,
+    Gender = 17,
+    GrowingEnvironment = 18,
+    Language = 19,
+    ModuleHostingType = 20,
+    ModuleType = 21,
+    ModuleState = 22,
+    Region = 23,
+    Rootstock = 24,
+    Salutation = 25,
+    SeasonState = 26,
+    SensorName = 27,
+    SensorState = 28,
+    TermAndCondition = 29,
+    PackageState = 30,
+    DocumentType = 31,
+    ModuleFederationType = 32,
+    PaymentCycle = 33,
+    PaymentMethod = 34,
+    PlantFamily = 35,
+    AlertCriteriaName = 36
+}

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

@@ -0,0 +1,99 @@
+import { AlertServiceBusMessage } from './ServiceBus';
+import { SystemMessage } from './SystemMessage';
+/**
+ * @deprecated should not be used anymore, will be removed in the near future (max 2 months)
+ */
+export type DeprecatedBaseProps = {
+    /**
+     * AlertRules, only for AlertRuleForcer to test
+     */
+    allAlertRules?: {
+        [moduleId: string]: string;
+    };
+    /**
+     * @deprecated use module-api and `modulePermissionToken` instead
+     */
+    token?: string;
+    /**
+     * @deprecated Not needed anymore
+     */
+    config?: RemoteComponentConfig;
+    /**
+     * @deprecated
+     */
+    addNotification?: (notification: OldAlertDto) => void;
+    /**
+     * @deprecated use `riseNotification` instead
+     */
+    serviceBusNotification?: (message: AlertServiceBusMessage, //currently only used for alerts
+    apiKey: string, queue: string, topic: string) => Promise<unknown>;
+    /**
+     * @deprecated Use `showMessage` instead
+     */
+    addMessage?: (message: SystemMessage) => void;
+    /**
+     * @deprecated Use `addBreadcrumbTranslation` instead
+     */
+    addTranslation?: (translation: {
+        key: string;
+        value: string;
+    }, hide?: boolean) => void;
+    /**
+     * @deprecated Use `navigateInHortiview` instead
+     */
+    navigateTo?: (path: string) => void;
+};
+/**
+ * @deprecated should not be used anymore
+ */
+export type RemoteComponentConfig = {
+    isBaseModule?: boolean;
+    /**
+     * The relative path to the shared module, e.g. ./MyModule
+     */
+    module: string;
+    /**
+     * The path to the remote container entry. The url were the app is running or the path to location of the remote js file, e.g. http://localhost:3000/remoteEntry.js
+     */
+    path: string;
+    /**
+     * name of the remote app, like sprayingbook
+     */
+    scope: string;
+    /**
+     * name of the module
+     */
+    name?: string;
+    /**
+     * name of the icon
+     */
+    icon?: string;
+    /**
+     * if the module has an error
+     */
+    error?: boolean;
+    /**
+     * the short name of the module
+     */
+    shortName: string;
+    /**
+     * the id of the module - used as alias
+     */
+    id: string;
+};
+/**
+ * @deprecated should not be used anymore
+ */
+export type OldAlertDto = {
+    id: string;
+    farmOrganizationId: string;
+    moduleName: string;
+    criteriaIcon?: string | null | JSX.Element;
+    criteriaName: string;
+    description: string | JSX.Element;
+    timeStamp: Date;
+    isRead: boolean;
+    isSnoozed: boolean;
+    title: string;
+    link?: string;
+};