@geowiki/core 0.15.0-dev.1

package/dist/index.d.mts

@@ -0,0 +1,1404 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryResult } from '@tanstack/react-query';
+import * as _geowiki_evoland_api_proxy from '@geowiki/evoland-api-proxy';
+import { ListLocationsRequest, SetUserRoleRequest, SetUserDetailRequest } from '@geowiki/evoland-api-proxy';
+import * as _geowiki_api_proxy from '@geowiki/api-proxy';
+import { ApplicationConfigurationDto, ResourceFilterInput, CurrentUserDto, EmailSettingsDto, GetFeatureListResultDto, GetPermissionListResultDto, ProfileDto, CountryDto, FileDto, FarmerClusterNewsDto, LocationDto } from '@geowiki/api-proxy';
+import * as _geowiki_cms_proxy from '@geowiki/cms-proxy';
+import { ClusterFilterSettingsItemDto, ConfigSettingsItemDto, GeoWikiSettingsItemDto, IntroTourSettingsItemDto, PublicationSettingsItemDto, MapSettingsItemDto, FundingSettingsItemDto, FooterSettingsItemDto, MenuItemDto, MapMenuItemItemDto, LayerItemDto, PageItemDto } from '@geowiki/cms-proxy';
+import { MutableRefObject } from 'react';
+import GeoJSON from 'geojson';
+import * as zustand from 'zustand';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { I18n } from 'next-localization';
+import { GetServerSidePropsContext } from 'next';
+import { Session } from 'next-auth';
+
+declare const easing: number[];
+declare const listVariants: {
+    initial: {
+        scale: number;
+        y: number;
+        opacity: number;
+    };
+    enter: {
+        scale: number;
+        y: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+            staggerChildren: number;
+            delayChildren: number;
+        };
+    };
+    exit: {
+        transition: {
+            staggerChildren: number;
+            staggerDirection: number;
+        };
+    };
+};
+declare const itemVariants: {
+    initial: {
+        y: number;
+        opacity: number;
+        transition: {
+            y: {
+                stiffness: number;
+            };
+        };
+    };
+    enter: {
+        y: number;
+        opacity: number;
+        transition: {
+            y: {
+                stiffness: number;
+                velocity: number;
+            };
+        };
+    };
+    exit: {
+        y: number;
+        opacity: number;
+        transition: {
+            y: {
+                stiffness: number;
+                velocity: number;
+            };
+        };
+    };
+};
+declare const slideInUp: {
+    exit: {
+        y: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    enter: {
+        y: number;
+        opacity: number;
+        transition: {
+            delay: number;
+            duration: number;
+            ease: number[];
+        };
+    };
+};
+declare const delayedSlideInUp: {
+    exit: {
+        y: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    enter: {
+        y: number;
+        opacity: number;
+        transition: {
+            delay: number;
+            duration: number;
+            ease: number[];
+        };
+    };
+};
+declare const slideInLeft: {
+    exit: {
+        x: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    enter: {
+        x: number;
+        opacity: number;
+        transition: {
+            delay: number;
+            duration: number;
+            ease: number[];
+        };
+    };
+};
+declare const slideInRight: {
+    exit: {
+        x: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+    enter: {
+        x: number;
+        opacity: number;
+        transition: {
+            duration: number;
+            ease: number[];
+        };
+    };
+};
+declare const spring: {
+    type: string;
+    stiffness: number;
+    damping: number;
+};
+
+declare const QueryConstants: {
+    GetUsers: string;
+    GetTenants: string;
+    GetRoles: string;
+    GetAppConfig: string;
+    GetFeatures: string;
+    GetTranslations: string;
+    GetPermissions: string;
+    GetUserRoles: string;
+    SetUserDetail: string;
+    GetEmailing: string;
+    GetAssignableRoles: string;
+    GetProfile: string;
+    GetProjects: string;
+    GetProjectDetails: string;
+    GetProjectResultSet: string;
+    DownlaodProjectsPoints: string;
+    GetProjectStatisticsByUser: string;
+    GetContractStatisticsByUser: string;
+    GetGroupsInProject: string;
+    UpdateActiveGroupsInProject: string;
+    GetProjectUsers: string;
+    GetUserProject: string;
+    SetProjectUser: string;
+    GetLocations: string;
+    UploadLocations: string;
+    GetLatestTaskOnLocation: string;
+    GetTasksPerLocation: string;
+    GetTaskComment: string;
+    GetTaskStatusList: string;
+    GetTaskAnnotation: string;
+    GetTaskMultipleAnnotations: string;
+    GetTaskSavedAnnotations: string;
+    DeleteTask: string;
+    GetApiImage: string;
+    GetCmsImage: string;
+    GetQuestionnaireForProject: string;
+    GetTaskAnswers: string;
+    UploadTasks: string;
+    UploadReviewTasks: string;
+};
+
+declare const useEvolandBands: () => _tanstack_react_query.UseQueryResult<void, Error>;
+
+declare const useEvolandWmsLayers: () => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.LayersResponse, Error>;
+
+declare const useApiUrl: () => string;
+
+declare const useAppConfig: () => UseQueryResult<ApplicationConfigurationDto, unknown>;
+
+declare const useAudience: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.KeyValuePairOfString_String[], Error>;
+
+declare const useCluster: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ClusterDto, Error>;
+
+declare const useClusterFilterSettings: () => _tanstack_react_query.UseQueryResult<ClusterFilterSettingsItemDto, Error>;
+declare const useConfigSettings: () => _tanstack_react_query.UseQueryResult<ConfigSettingsItemDto, Error>;
+
+declare const useClusterMapInfo: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ClusterMapInfoDto[], Error>;
+
+declare const useClusters: (fetchAll?: boolean, sort?: string, skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfClusterDto, Error>;
+declare const useAllNewsFromAllClusters: (sort?: string, skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfFarmerClusterNewsInfoDto, Error>;
+
+declare const useCmsUrl: () => string;
+
+declare const useCountries: (fetchAll?: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.CountryDto[], Error>;
+
+declare const useDimensions: (ref: MutableRefObject<any>) => {
+    width: number;
+    height: number;
+};
+
+declare const useFeature: (key: string) => boolean;
+
+declare const useFileUrl: () => string;
+declare const useFileUpload: (formData?: {
+    files?: Array<Blob>;
+}) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FileDto[], Error>;
+
+declare const useFilterClusters: (filter: any) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfClusterDto, Error>;
+
+declare const useGeoWikiSettings: () => _tanstack_react_query.UseQueryResult<GeoWikiSettingsItemDto, Error>;
+
+declare const useImageUrl: () => string;
+
+declare const useIntroTourSettings: () => _tanstack_react_query.UseQueryResult<IntroTourSettingsItemDto, Error>;
+
+declare const useIsAdmin: () => boolean | undefined;
+
+declare const useIsAuthenticated: () => boolean | undefined;
+
+declare const useIsInRole: (role: string) => {
+    data: boolean | undefined;
+    isLoading: boolean;
+};
+
+declare const useLanguages: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.KeyValuePairOfString_String[], Error>;
+
+interface LegendInfo {
+    Legend: Legend[];
+}
+interface Legend {
+    layerName: string;
+    title: string;
+    rules: Rule[];
+}
+interface Rule {
+    symbolizers: Symbolizer[];
+    name?: string;
+    title?: string;
+    abstract?: string;
+    filter?: string;
+}
+interface Symbolizer {
+    Raster?: Raster;
+    Point?: Point;
+    Polygon?: Polygon;
+    Line?: Line;
+    Text?: Text;
+}
+interface Line {
+    stroke: string;
+    strokeWidth: string;
+    "stroke-opacity": string;
+    strokeLinecap: string;
+    strokeLinejoin: string;
+}
+interface Point {
+    title: string;
+    abstract: string;
+    url: string;
+    size: string;
+    opacity: string;
+    rotation: string;
+    graphics: Graphic[];
+}
+interface Graphic {
+    mark: string;
+    fill: string;
+    "fill-opacity": string;
+}
+interface Polygon {
+    fill: string;
+    "fill-opacity": string;
+}
+interface Raster {
+    colormap: Colormap;
+    opacity: string;
+}
+interface Colormap {
+    entries: Entry[];
+    type: string;
+}
+interface Entry {
+    label: string;
+    quantity: string;
+    color: string;
+    opacity: string;
+}
+interface Text {
+    label: string;
+    fonts: Font[];
+    "label-placement": LabelPlacement;
+}
+interface Font {
+    "font-family": string[];
+    "font-style": string;
+    "font-weight": string;
+    "font-size": string;
+}
+interface LabelPlacement {
+    "x-anchor": string;
+    "y-anchor": string;
+    rotation: string;
+}
+
+declare const useLayerInfo: (url: string, layerName: string) => _tanstack_react_query.UseQueryResult<LegendInfo, Error>;
+
+declare function useLocation(): GeolocationCoordinates | undefined;
+declare const useLocationsForProject: (locationreq: ListLocationsRequest) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.ListLocationsResponse, Error>;
+declare const useLocationBulkUpload: (uploadLocations: boolean, file: Blob, project_id: number, group_id: number) => _tanstack_react_query.UseQueryResult<Record<string, any>, Error>;
+declare const useTaskBulkUpload: (uploadTasks: boolean, file: Blob, project_id: number) => _tanstack_react_query.UseQueryResult<Record<string, any>, Error>;
+declare const useReviewTaskBulkUpload: (uploadReviewTasks: boolean, file: Blob, project_id: number) => _tanstack_react_query.UseQueryResult<Record<string, any>, Error>;
+
+declare function useLockBodyScroll(): void;
+
+declare const useNews: (lang?: string, skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ExternalNewsDto[] | null | undefined, Error>;
+
+declare const DOTS = "...";
+interface UsePaginationProps {
+    totalCount: number;
+    pageSize: number;
+    siblingCount: number;
+    currentPage: number;
+}
+declare const usePagination: ({ totalCount, pageSize, siblingCount, currentPage, }: UsePaginationProps) => (string | number)[] | undefined;
+
+declare const usePermission: (key: string) => boolean;
+
+declare const usePublicationSettings: () => _tanstack_react_query.UseQueryResult<PublicationSettingsItemDto, Error>;
+
+declare const useResource: (search?: string, sort?: string, skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfResourceDto, Error>;
+
+declare const useResourceFilter: (filter: ResourceFilterInput) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfResourceDto, Error>;
+
+declare const useResourceType: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.KeyValuePairOfString_String[], Error>;
+
+declare const useTopic: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.KeyValuePairOfString_String[], Error>;
+
+declare const useUserProfileGet: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ProfileDto, Error>;
+
+declare const useUsers: (pageIndex: number, pageSize: number, filter?: string | undefined, sorting?: string | undefined) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfIdentityUserDto, Error>;
+
+declare function useRenderInfo(name?: string): {
+    name: string;
+    renders: number;
+    sinceLastRender: number;
+    timestamp: number;
+} | undefined;
+
+interface DefaultSettings {
+    generalSettings: GeoWikiSettingsItemDto;
+    mapSettings: MapSettingsItemDto;
+    fundingSettings: FundingSettingsItemDto;
+    footerSettings: FooterSettingsItemDto;
+    publicationSettings: PublicationSettingsItemDto;
+    mainMenu: MenuItemDto;
+}
+
+declare const useDefaultSettings: () => _tanstack_react_query.UseQueryResult<DefaultSettings, Error>;
+
+declare const useCurrentUser: () => CurrentUserDto | undefined;
+
+declare const useEmailing: () => UseQueryResult<EmailSettingsDto, unknown>;
+
+type Policy = "AbpIdentity.Roles" | "AbpIdentity.Roles.Create" | "AbpIdentity.Roles.Update" | "AbpIdentity.Roles.Delete" | "AbpIdentity.Roles.ManagePermissions" | "AbpIdentity.Users" | "AbpIdentity.Users.Create" | "AbpIdentity.Users.Update" | "AbpIdentity.Users.Delete" | "AbpIdentity.Users.ManagePermissions" | "AbpTenantManagement.Tenants" | "AbpTenantManagement.Tenants.Create" | "AbpTenantManagement.Tenants.Update" | "AbpTenantManagement.Tenants.Delete" | "AbpTenantManagement.Tenants.ManageFeatures" | "AbpTenantManagement.Tenants.ManageConnectionStrings" | "FeatureManagement.ManageHostFeatures" | "SettingManagement.Emailing" | "SettingManagement.Emailing.Test";
+declare const useGrantedPolicies: () => {
+    can: (key: Policy) => boolean;
+};
+
+declare const useFeatures: (providerName: string | undefined, providerKey: string | undefined) => UseQueryResult<GetFeatureListResultDto, unknown>;
+
+declare const useAssignableRoles: () => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ListResultDtoOfIdentityRoleDto, Error>;
+
+type UseUserRolesProps = {
+    userId: string;
+};
+declare const useUserRoles: ({ userId }: UseUserRolesProps) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ListResultDtoOfIdentityRoleDto, Error>;
+
+declare const usePermissions: (providerName: string | undefined, providerKey: string | undefined) => UseQueryResult<GetPermissionListResultDto, unknown>;
+
+declare const useRoles: (pageIndex: number, pageSize: number, filter?: string | undefined, sorting?: string | undefined) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfIdentityRoleDto, Error>;
+
+declare const useProfile: () => UseQueryResult<ProfileDto, unknown>;
+
+declare const useTenants: (pageIndex: number, pageSize: number, filter?: string | undefined, sorting?: string | undefined) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfTenantDto, Error>;
+
+declare const useEvolandLabels: (projectId: number) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.LabelsResponse, Error>;
+
+declare const useLookUp: (ServiceName: string, params: any, LookUpsClusterCountries: string, LookUpsClusterActivityStatus: string, LookUpsClusterFarmingSystem: string, LookUpsClusterMainAgricultureArea: string, LookUpsClusterMainCrops: string) => _tanstack_react_query.UseQueryResult<string[] | CountryDto[] | undefined, Error>;
+
+declare enum TaskStatus {
+    ASSIGNED = "ASSIGNED",
+    SKIPPED = "SKIPPED",
+    IN_REVIEW = "IN_REVIEW",
+    SUBMITTED = "SUBMITTED",
+    TO_FIX = "TO_FIX",
+    ACCEPTED = "ACCEPTED",
+    USER_DISCARDED = "USER_DISCARDED",
+    DISCARDED = "DISCARDED"
+}
+declare enum TaskStatusColor {
+    ASSIGNED = "goldenrod",
+    SKIPPED = "darkgray",
+    IN_REVIEW = "pink",
+    TO_FIX = "red",
+    ACCEPTED = "violet",
+    DISCARDED = "aqua",
+    SUBMITTED = "green",
+    USER_DISCARDED = "orange"
+}
+declare enum TaskEventType {
+    CREATED = "CREATED",
+    NEW_ANNOTATION = "NEW_ANNOTATION",
+    STATUS_UPDATED = "STATUS_UPDATED",
+    COMMENT = "COMMENT",
+    QUESTIONNAIRE = "QUESTIONNAIRE",
+    REVIEW = "REVIEW"
+}
+declare enum TaskState {
+    ASSIGNED = "Assigned",
+    SKIPPED = "Skip",
+    IN_REVIEW = "Ask to Review",
+    SUBMITTED = "Submit",
+    TO_FIX = "To Fix",
+    ACCEPTED = "Accept",
+    USER_DISCARDED = "Discard",
+    DISCARDED = "Discard"
+}
+declare enum AnnotationRequired {
+    NOT_REQUIRED = "NOT_REQUIRED",
+    REQUIRED = "REQUIRED",
+    OPTIONAL = "OPTIONAL"
+}
+declare enum QuestionnaireType {
+    TEXT = "TEXT",
+    CONTEXT = "CONTEXT",
+    SINGLE_CHOICE = "SINGLE_CHOICE",
+    MULTI_CHOICE = "MULTI_CHOICE",
+    DATETIME = "DATETIME"
+}
+
+interface LocationTasks {
+    locationProjectId: number;
+    taskForReview: boolean;
+    orderBy?: string | null;
+    search?: string | null;
+    status?: TaskStatus | null;
+    statusIn?: string | null;
+    dateLte?: string | null;
+    dateGte?: string | null;
+    pageIdx?: number | null;
+    pageSize?: number | null;
+    userId?: string | null;
+    userUserAlias?: string | null;
+    userOrderBy?: string | null;
+    locationLocationId?: string | null;
+    locationOrderBy?: string | null;
+    locationGroupId?: string | null;
+    groupName?: string | null;
+    groupOrderBy?: string | null;
+}
+
+declare const useProjects: (fetch: boolean, start?: number, amount?: number) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.ListProjectResponse | undefined, Error>;
+declare const useProjectDetails: (projectId: number, update: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.UserProjectElement, Error>;
+declare const useTasksPerLocation: (data: LocationTasks) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.TaskFilterResponse, Error>;
+declare const useRandomTasksPerLocation: (data: LocationTasks) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.TaskResponse, Error>;
+declare const useTaskComments: (taskIds: number[]) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.TaskLatestCommentResponse, Error>;
+declare const useGroupsInProject: (projectId: number, updateGroup?: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.ProjectGroupResponse[], Error>;
+declare const useProjectUsers: (projectId: number) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.UserOut[], Error>;
+declare const useTaskStatusList: () => _tanstack_react_query.UseQueryResult<string[], Error>;
+declare const useUpdateActiveGroupInProject: (projectId: number, groupId: number, update: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GenericResponse | undefined, Error>;
+declare const useTaskAnnotation: (taskId: number | null) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.TaskAnnotationResponse | undefined, Error>;
+declare const useTaskMultipleAnnotations: (taskId: number | null) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.LocationAssetsResponse | undefined, Error>;
+declare const useTaskSavedAnnotations: (taskId: number | null) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GetSavedAnnotationResponse | undefined, Error>;
+declare const useTaskDelete: (taskId: number, projectId: number, deleteTask: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GenericResponse | undefined, Error>;
+declare const useProjectStatisticsByUser: (projectId: number, startDate: string | null, endDate: string, filterUserId: string | null) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.UserStatisticsResponse, Error>;
+declare const useContractStatisticsByUser: (projectId: number, startDate: string | null, endDate: string, filterUserId: string | null) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.UserStatisticsResponse, Error>;
+declare const useLatestTaskOnLocation: (locationId: string, projectId: number, referenceDate: string) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.LocationTaskAnnotationResponse, Error>;
+declare const useAssignProjectToUser: (userRoleRequest: SetUserRoleRequest[], update: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GenericResponse | undefined, Error>;
+declare const useGetUserProject: (user_id: string, fetchData: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GetUserRoleProjectResponse[] | undefined, Error>;
+declare const useUpdateUserDetail: (userDetailRequest: SetUserDetailRequest, update: boolean) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.GenericResponse | undefined, Error>;
+declare const useProjectsPointsDownload: (projectId: number, download: boolean, userRole: string) => _tanstack_react_query.UseQueryResult<any, Error>;
+declare const useQuestionnaire: (projectId: number) => _tanstack_react_query.UseQueryResult<_geowiki_evoland_api_proxy.Questionnaire[], Error>;
+declare const useTaskAnswers: (taskId: number) => _tanstack_react_query.UseQueryResult<any[][], Error>;
+declare const useProjectResultSet: (download: boolean, projectId: number, is_geo_json: boolean) => _tanstack_react_query.UseQueryResult<any, Error>;
+
+declare const useApiImage: (imageId: string) => _tanstack_react_query.UseQueryResult<string, Error>;
+
+declare const useCmsImage: (imageId: string) => _tanstack_react_query.UseQueryResult<string, Error>;
+
+declare const useClusterGetJoinRequests: (clusterId: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ClusterMemberDto[], Error>;
+
+declare const useClusterGetNews: (clusterId: string, newsId: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FarmerClusterNewsDto, Error>;
+
+declare const useClusterGetNewsNextPreviousStatus: (clusterId: string, newsId: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.NewsPreviousNextStatusDto, Error>;
+
+declare const useClusterImages: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FileDto[], Error>;
+
+declare const useClusterOverview: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.ClusterDto, Error>;
+
+declare const useClusterAllNews: (id: string, refresh: boolean, sorting?: string, skipCount?: number, maxResultCount?: number, status?: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfFarmerClusterNewsInfoDto, Error>;
+
+declare const useNewsFromAllClusters: (skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfFarmerClusterNewsInfoDto, Error>;
+
+declare const useClusterNewsWithId: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FarmerClusterNewsDto, Error>;
+
+declare const useMapMenuItems: () => _tanstack_react_query.UseQueryResult<MapMenuItemItemDto[], Error>;
+
+declare const useClusterLinks: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.LinksAndPartnerDto, Error>;
+
+declare const useCmsContentWithType: (contentType: string) => _tanstack_react_query.UseQueryResult<any, Error>;
+
+declare const useClusterNews: (id: string, sort?: string, skip?: number, take?: number) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.PagedResultDtoOfFarmerClusterNewsDto, Error>;
+
+declare const useClusterDescription: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FarmerClusterDescriptionDto, Error>;
+
+declare const useClusterDetails: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FarmerClusterDetailsDto, Error>;
+
+declare const useClusterImagesAndVideos: (id: string) => _tanstack_react_query.UseQueryResult<_geowiki_api_proxy.FarmerClusterImagesAndVideosDto, Error>;
+
+type HostInfo = {
+    host: string;
+    cmsUrl: string;
+    tenantId?: string;
+    hostType?: HostType;
+    name?: string;
+    redirectUrl?: string;
+    protectedPaths?: string[];
+};
+declare enum HostType {
+    IsActive = "IsActive",
+    IsUnderConstruction = "IsUnderConstruction"
+}
+
+declare function useHost(): _tanstack_react_query.UseQueryResult<HostInfo | null, Error>;
+
+declare function useHosts(): _tanstack_react_query.UseQueryResult<HostInfo[], Error>;
+
+declare const useCreateHost: () => _tanstack_react_query.UseMutationResult<HostInfo, Error, Omit<HostInfo, "host"> & {
+    host: string;
+}, unknown>;
+declare const useUpdateHost: () => _tanstack_react_query.UseMutationResult<HostInfo, Error, HostInfo, unknown>;
+declare const useDeleteHost: () => _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+
+/**
+ * Comprehensive HostService that abstracts all host-related operations
+ * This service provides a unified interface for both client and server-side host management
+ */
+declare class HostService {
+    /**
+     * Server-side: Get all hosts data
+     * This should be used in API routes and server-side code
+     */
+    static getHostData(): HostInfo[];
+    /**
+     * Server-side: Find host info by hostname
+     * This should be used in API routes and server-side code
+     */
+    static findHostInfo(host: string): HostInfo | undefined;
+    /**
+     * Server-side: Get CMS URL for a specific host
+     * This should be used in API routes and server-side code
+     */
+    static getCmsUrlForHost(host: string): string;
+    /**
+     * Server-side: Get tenant ID for a specific host
+     * This should be used in API routes and server-side code
+     */
+    static getTenantIdForHost(host: string): string | undefined;
+    /**
+     * Utility: Check if host is under construction
+     */
+    static isHostUnderConstruction(hostInfo: HostInfo | undefined): boolean;
+    /**
+     * Utility: Check if host has protected paths
+     */
+    static hasProtectedPaths(hostInfo: HostInfo | undefined): boolean;
+    /**
+     * Utility: Check if a path is protected for a host
+     */
+    static isPathProtected(hostInfo: HostInfo | undefined, path: string): boolean;
+    /**
+     * Utility: Get redirect URL for host
+     */
+    static getRedirectUrl(hostInfo: HostInfo | undefined): string | undefined;
+    /**
+     * Utility: Get tenant name from host info
+     */
+    static getTenantName(hostInfo: HostInfo | undefined): string | undefined;
+    /**
+     * Utility: Validate host configuration
+     */
+    static validateHostInfo(hostInfo: HostInfo): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Utility: Check if URL is valid
+     */
+    private static isValidUrl;
+    /**
+     * Utility: Check if path is valid
+     */
+    private static isValidPath;
+    /**
+     * Utility: Get host info for current window location (client-side only)
+     */
+    static getCurrentHostInfo(hosts: HostInfo[]): HostInfo | undefined;
+    /**
+     * Utility: Get host info for specific hostname from hosts array
+     */
+    static getHostInfoFromArray(hosts: HostInfo[], hostname: string): HostInfo | undefined;
+    /**
+     * Utility: Filter hosts by tenant ID
+     */
+    static filterHostsByTenant(hosts: HostInfo[], tenantId: string): HostInfo[];
+    /**
+     * Utility: Filter hosts by CMS URL
+     */
+    static filterHostsByCmsUrl(hosts: HostInfo[], cmsUrl: string): HostInfo[];
+    /**
+     * Utility: Get unique tenant IDs from hosts
+     */
+    static getUniqueTenantIds(hosts: HostInfo[]): string[];
+    /**
+     * Utility: Get unique CMS URLs from hosts
+     */
+    static getUniqueCmsUrls(hosts: HostInfo[]): string[];
+}
+
+type MapLayer = {
+    id: string;
+    name: string;
+    type: string;
+    url: string;
+    visible: boolean;
+    opacity: number;
+    attribution: string;
+    layerName: string;
+    layerItem: LayerItemDto;
+};
+
+type Alert = {
+    heading: string;
+    message: string;
+};
+
+type BaseProp = {
+    settings: DefaultSettings;
+};
+
+declare enum StyleType {
+    Primary = 0,
+    Secondary = 1,
+    Success = 2,
+    Danger = 3,
+    Warning = 4,
+    Info = 5
+}
+
+interface ClusterDto {
+    name: string;
+    description: string;
+    aim: string;
+    noOfFarms: number;
+    bioDiversityInterestsAndFocusAreas: string;
+    adminUserID: string;
+    contactEmail: string;
+    coverImageID: string;
+    images: FileDto[];
+    clusterNews: FarmerClusterNewsDto[];
+    location: LocationDto;
+    dateEstablished: Date;
+    farmingSystems: string[];
+    mainAgriculturalAreas: string[];
+    mainCrops: string[];
+    liveStock: string[];
+    otherLandScapeElements: string[];
+    huntingManagement: string[];
+    bioDiversityEnhancingMeasures: string;
+    outcomes: string;
+    funding: string[];
+    fundingSpecified: string;
+    previousFundingSpecified: string;
+    website: string;
+    projectURL: string;
+    videoURL: string;
+    climate: string;
+    totalArea: number;
+    isDeleted: boolean;
+    deleterID: string;
+    deletionTime: Date;
+    lastModificationTime: Date;
+    lastModifierID: string;
+    creationTime: Date;
+    creatorID: string;
+    id: string;
+}
+
+type Column = {
+    name: string;
+    label: string;
+    render: any;
+};
+
+type DisplayItem = {
+    value: any;
+    label: any;
+};
+
+interface FluffyThumbnail {
+    contentUrl: string;
+}
+
+type LinkWithNewTab = {
+    url: string;
+    new_tab: boolean;
+    text: string;
+};
+
+type FooterSettings = {
+    copyright: string;
+    links: Array<LinkWithNewTab>;
+};
+
+type FundingSettings = {
+    image: string;
+    title: string;
+    description: string;
+};
+
+type GlobalSettings = {
+    title: string;
+    description: string;
+    logo: string;
+    logo_alt: string;
+    host: string;
+    client_url: string;
+    identity_url: string;
+    api_url: string;
+    brand_name: string;
+    is_active: boolean;
+    can_login: boolean;
+};
+
+type MenuItem = {
+    id: string;
+    name: string;
+    url: string;
+    newTab?: boolean;
+    children?: MenuItem[];
+};
+
+type MainMenu = {
+    id: string;
+    name: string;
+    items: MenuItem[];
+};
+
+type MapSettings = {
+    latitude: number;
+    longitude: number;
+    zoom: number;
+};
+
+interface QueryContext {
+    originalQuery: string;
+    adultIntent: boolean;
+}
+
+interface Sort {
+    name: string;
+    id: string;
+    isSelected: boolean;
+    url: string;
+}
+
+interface ProviderImage {
+    thumbnail: FluffyThumbnail;
+}
+
+interface Provider {
+    _type: string;
+    name: string;
+    image?: ProviderImage;
+}
+
+interface PurpleThumbnail {
+    contentUrl: string;
+    width: number;
+    height: number;
+}
+
+interface ValueImage {
+    thumbnail: PurpleThumbnail;
+}
+
+interface BingNewsItem {
+    name: string;
+    url: string;
+    image?: ValueImage;
+    description: string;
+    provider: Provider[];
+    datePublished: Date;
+}
+
+interface NewsResult {
+    _type: string;
+    readLink: string;
+    queryContext: QueryContext;
+    totalEstimatedMatches: number;
+    sort: Sort[];
+    value: BingNewsItem[];
+}
+
+interface UtmResult {
+    geometry: GeoJSON.Polygon;
+    epsg: number;
+    utm_bounds: number[];
+    location_id?: string;
+}
+
+declare enum ViewStatus {
+    New = 0,
+    Edit = 1,
+    List = 2,
+    View = 3
+}
+
+type State$3 = {
+    breadCrumbs: any[];
+    add: (breadCrumb: any) => void;
+    remove: (breadCrumb: any) => void;
+};
+declare const useBreadCrumbStore: zustand.UseBoundStore<zustand.StoreApi<State$3>>;
+
+type ConfigState = {
+    apiUrl: string;
+    cmsUrl: string;
+    tenantId: string;
+};
+declare const configStore: zustand_vanilla.StoreApi<ConfigState>;
+
+type State$2 = {
+    layers: LayerItemDto[];
+    add: (layer: LayerItemDto) => void;
+    remove: (layer: LayerItemDto) => void;
+};
+declare const useLayerStore: zustand.UseBoundStore<zustand.StoreApi<State$2>>;
+
+type State$1 = {
+    settings: DefaultSettings | null;
+};
+declare const settingsStore: zustand_vanilla.StoreApi<State$1>;
+
+type State = {
+    showPanels: () => void;
+    isLeftPanelOpen: boolean;
+    setIsLeftPanelOpen: (isLeftPanelOpen: boolean) => void;
+    isRightPanelOpen: boolean;
+    setIsRightPanelOpen: (isRightPanelOpen: boolean) => void;
+    panelRef: any;
+    setPanelRef: (panelRef: any) => void;
+};
+declare const usePanelStore: zustand.UseBoundStore<zustand.StoreApi<State>>;
+
+type BasfLayerItem = {
+    id: string;
+    opacity: number;
+    scenario: string;
+    price: string;
+    product: string;
+    item: string;
+    year: string;
+    enabled: boolean;
+    formType: string;
+};
+type Store = {
+    selectedItems: BasfLayerItem[];
+    addItem: (item: Omit<BasfLayerItem, "opacity">) => void;
+    removeItem: (id: string) => void;
+    updateItemOpacity: (id: string, opacity: number) => void;
+    updateItemEnabled: (id: string, enabled: boolean) => void;
+    rightPanelOpen: boolean;
+    leftPanelOpen: boolean;
+    updateRightPanelOpen: (open: boolean) => void;
+    updateLeftPanelOpen: (open: boolean) => void;
+};
+declare const useBasfStore: zustand.UseBoundStore<zustand.StoreApi<Store>>;
+
+declare const i18n: I18n<any>;
+declare const getHtmlElementFromReactNode: (node: React.ReactNode) => HTMLDivElement;
+declare const classNames: (...classes: any) => any;
+declare function getButtonAppearance(type: any, background: any): "dark" | "white" | "dark-outline" | "white-outline";
+declare function getMediaUrl(url: string): string | undefined;
+declare const showIntroTour: (tourSteps: []) => void;
+declare const tokenData: (token: string, field: string) => any;
+declare const IsTokenExpired: (tokenExpires: string) => boolean | undefined;
+declare const getHostFromRequest: (req: any) => any;
+declare const shimmer: (w: number, h: number) => string;
+declare const toBase64: (str: string) => string;
+declare const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+declare const triplet: (e1: number, e2: number, e3: number) => string;
+declare const rgbDataURL: (r: number, g: number, b: number) => string;
+declare const downloadData: (data: any, fileName: string) => void;
+declare const scrollToFirstErrorElement: (errors: any) => void;
+declare const downloadJSON: (data: object, fileName: string) => void;
+declare const formatUnixDate: (date: number) => string;
+
+declare const Config: {
+    site_name: string;
+    title: string;
+    description: string;
+    locale: string;
+};
+declare const Permission: {
+    FarmerCluster: {
+        Default: string;
+        Create: string;
+        Update: string;
+        Delete: string;
+        AddNews: string;
+        EditNews: string;
+        DeleteNews: string;
+        ViewNews: string;
+        ViewFarmers: string;
+        RemoveFarmer: string;
+        AddFarmer: string;
+    };
+    Resource: {
+        Default: string;
+        Create: string;
+        Update: string;
+        Delete: string;
+    };
+    File: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+    };
+    News: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+    };
+    Tenants: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+        ManageConnectionStrings: string;
+        ManageFeatures: string;
+    };
+    Layer: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+    };
+    LayerCategory: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+    };
+    LayerInfo: {
+        Default: string;
+        Create: string;
+        Delete: string;
+        Update: string;
+    };
+    Settings: {
+        Default: string;
+        Create: string;
+        Update: string;
+    };
+    Dashboard: {
+        Default: string;
+    };
+};
+declare enum USER_ROLE {
+    ADMIN = "admin",
+    FARMER_CLUSTER_ADMIN = "FarmerClusterAdmin"
+}
+declare enum PermissionProvider {
+    U = "U",
+    R = "R",
+    T = "T"
+}
+type Menu = {
+    name: string;
+    link?: string;
+    icon?: any;
+    roles?: USER_ROLE[];
+    feature?: string[];
+};
+interface SubMenu extends Menu {
+    children?: Menu[];
+}
+declare const Features: {
+    FarmerCluster: string;
+    FarmerClusterNews: string;
+    SettingManagementEnable: string;
+    GeoWikiLogin: string;
+    GeoWikiSettings: string;
+    SettingManagementAllowTenantsToChangeEmailSettings: string;
+    Resources: string;
+};
+declare const FarmingSystem: {
+    value: string;
+    label: string;
+}[];
+declare const MainAgriculturalAreas: {
+    value: string;
+    label: string;
+}[];
+declare const MainCrops: {
+    value: string;
+    label: string;
+}[];
+declare const LiveStock: {
+    value: string;
+    label: string;
+}[];
+declare const OtherLandscapeElements: {
+    value: string;
+    label: string;
+}[];
+declare const HuntingManagement: {
+    value: string;
+    label: string;
+}[];
+declare const ClusterFunding: {
+    value: string;
+    label: string;
+}[];
+declare const ActivityStatus: {
+    value: string;
+    label: string;
+}[];
+declare const routes: {
+    EditFarmerCluster: {
+        path: string;
+        name: string;
+    }[];
+    ViewFarmerClusterNews: {
+        path: string;
+        name: string;
+    }[];
+};
+declare const imageMaxDimension: {
+    width: number;
+    height: number;
+};
+declare const imageMinDimension: {
+    width: number;
+    height: number;
+};
+declare const ImageError = "Image size requires a minimum 400px width and 250px height and is limited to max 1920px width and 1080px height.";
+declare const ColorArray: string[];
+declare const ColorArrayCSSClass: string[];
+declare const Responsive: {
+    desktop: {
+        breakpoint: {
+            max: number;
+            min: number;
+        };
+        items: number;
+        slidesToSlide: number;
+    };
+    tablet: {
+        breakpoint: {
+            max: number;
+            min: number;
+        };
+        items: number;
+        slidesToSlide: number;
+    };
+    mobile: {
+        breakpoint: {
+            max: number;
+            min: number;
+        };
+        items: number;
+        slidesToSlide: number;
+    };
+};
+declare const ResourcesMenu: {
+    id: string;
+    name: string;
+    url: string;
+    newTab: boolean;
+    children: {
+        id: string;
+        name: string;
+        url: string;
+        newTab: boolean;
+    }[];
+}[];
+declare const NewsDefaultImage = "3a084680-7984-e07d-d44e-d58f946604e3";
+declare const LookUps: {
+    ClusterCountries: string;
+    ClusterActivityStatus: string;
+    ClusterFarmingSystem: string;
+    ClusterMainAgricultureArea: string;
+    ClusterMainCrops: string;
+};
+declare const AdminMenus: SubMenu[];
+declare const CLUSTER_ACTIVITY_STATUS: {
+    value: string;
+    label: string;
+}[];
+
+declare const getGeoWikiSettings: () => Promise<GeoWikiSettingsItemDto>;
+declare const getDefaultSettings: () => Promise<DefaultSettings>;
+declare const getMenus: (displayName: string) => Promise<MenuItemDto>;
+declare const getPageContent: (displayName: string) => Promise<PageItemDto>;
+declare const getContentWithTypeAndDisplayName: (contentType: string, displayName: string) => Promise<_geowiki_cms_proxy.QueriesItemsDto>;
+declare const getContentWithSlug: (slug: string) => Promise<any>;
+declare const getContentsWithType: (contentType: string) => Promise<any>;
+declare const getPageProps: (ctx: GetServerSidePropsContext) => Promise<{
+    props: {
+        page: PageItemDto;
+    };
+}>;
+
+/**
+ * Analytics utilities for tracking user interactions with Umami
+ *
+ * Usage Examples:
+ *
+ * // Track download events
+ * import { trackDownloadEvent } from "@geowiki/core";
+ * trackDownloadEvent.attempt("csv", "Germany", "2023", "Research", session);
+ * trackDownloadEvent.success("data.csv", "Research", session);
+ * trackDownloadEvent.failure("Network error", "Research", session);
+ *
+ * // Track authentication events
+ * import { trackAuthEvent } from "@geowiki/core";
+ * trackAuthEvent.loginAttempt("openiddict", session);
+ * trackAuthEvent.loginSuccess("openiddict", session);
+ *
+ * // Track general user events
+ * import { trackUserEvent } from "@geowiki/core";
+ * trackUserEvent.buttonClick("download", "map-page", session);
+ * trackUserEvent.pageView("/map", session);
+ */
+declare global {
+    interface Window {
+        umami?: {
+            track: (eventName: string, eventData?: Record<string, any>) => void;
+        };
+    }
+}
+/**
+ * Utility function to track Umami events with user info
+ * @param eventName - The name of the event to track
+ * @param eventData - Additional data to include with the event
+ * @param session - Optional session object containing user information
+ */
+declare const trackUmamiEvent: (eventName: string, eventData?: Record<string, any>, session?: Session & {
+    accessToken?: string;
+}) => void;
+/**
+ * Track download-related events with consistent data structure
+ */
+declare const trackDownloadEvent: {
+    /**
+     * Track download attempt
+     */
+    attempt: (format: string, country: string, version: string, purpose: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track successful download
+     */
+    success: (filename: string, purpose: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track download failure
+     */
+    failure: (error: string, purpose: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track login attempt for download access
+     */
+    loginAttempt: (session?: Session & {
+        accessToken?: string;
+    }) => void;
+};
+/**
+ * Track authentication-related events
+ */
+declare const trackAuthEvent: {
+    /**
+     * Track login attempt
+     */
+    loginAttempt: (provider: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track successful login
+     */
+    loginSuccess: (provider: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track logout
+     */
+    logout: (session?: Session & {
+        accessToken?: string;
+    }) => void;
+};
+/**
+ * Track general user interaction events
+ */
+declare const trackUserEvent: {
+    /**
+     * Track page view
+     */
+    pageView: (page: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track button click
+     */
+    buttonClick: (buttonName: string, context?: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track form submission
+     */
+    formSubmit: (formName: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track map control button click with specific context
+     */
+    mapControlClick: (controlName: string, action?: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+};
+/**
+ * Track map control events
+ */
+declare const trackMapEvent: {
+    /**
+     * Track layer toggle
+     */
+    layerToggle: (layerName: string, action: "add" | "remove", session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track base layer change
+     */
+    baseLayerChange: (baseLayerName: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track layer opacity change
+     */
+    layerOpacityChange: (layerName: string, opacity: number, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track layer reorder
+     */
+    layerReorder: (layerName: string, newPosition: number, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track layer info view
+     */
+    layerInfoView: (layerName: string, session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track measurement tool usage
+     */
+    measurementTool: (action: "start" | "stop" | "clear", session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track zoom control usage
+     */
+    zoomControl: (action: "zoom_in" | "zoom_out" | "reset", session?: Session & {
+        accessToken?: string;
+    }) => void;
+    /**
+     * Track legend interaction
+     */
+    legendInteraction: (action: "open" | "close" | "reorder", session?: Session & {
+        accessToken?: string;
+    }) => void;
+};
+
+/**
+ * Server-side utility to get host data without using React hooks
+ * This is used in API routes and server-side code where hooks cannot be used
+ */
+declare const getHostData: () => HostInfo[];
+/**
+ * Find host info by hostname
+ */
+declare const findHostInfo: (host: string) => HostInfo | undefined;
+/**
+ * Get CMS URL for a specific host
+ */
+declare const getCmsUrlForHost: (host: string) => string;
+/**
+ * Get tenant ID for a specific host
+ */
+declare const getTenantIdForHost: (host: string) => string | undefined;
+
+declare const QueryNames: {
+    Users: string;
+    Tenants: string;
+    Roles: string;
+    AppConfig: string;
+    GetMapMenuItems: string;
+    GetApps: string;
+    GetCountries: string;
+    Clusters: string;
+    Cluster: string;
+    ClusterNewsWithId: string;
+    GetClusterOverview: string;
+    FilterClusters: string;
+    ClusterLookUp: string;
+    JoinRequests: string;
+    GetFarmerCluster: string;
+    GetFarmerClusterNews: string;
+    GetFarmerClusterMembers: string;
+    Menus: string;
+    GetMenu: string;
+    GetSettings: string;
+    Layers: string;
+    GetLayer: string;
+    GetClusterForMap: string;
+    GetAppSettings: string;
+    GetResource: string;
+    FileUpload: string;
+    GetUserProfile: string;
+    GetLookUp: string;
+    GetClusterFilterSettings: string;
+    GetConfig: string;
+    GetIntroTour: string;
+    GetNews: string;
+    GetPublicationSettings: string;
+    GetUseLayerInfo: string;
+    GetMapSettings: string;
+    GetLanguages: string;
+    GetResourceFilter: string;
+    GetAudience: string;
+    GetTopic: string;
+    GetResourceType: string;
+    GetAvailableWmsLayers: string;
+    GetAvailableBands: string;
+    ClusterAllNews: string;
+    ClusterNews: string;
+    ClusterGetNews: string;
+    ClusterNewsNextPrevious: string;
+    ClusterImages: string;
+    DefaultSettings: string;
+    GetEvolandLabels: string;
+    GetEvolandCombinationLabels: string;
+    NewsFromAllClusters: string;
+    MapMenuItems: string;
+    GetSocialLinks: string;
+    GetCmsContentWithType: string;
+    GetImagesAndVideos: string;
+    GetClusterDescription: string;
+    GetClusterDetails: string;
+    GetHost: string;
+    GetHosts: string;
+};
+
+export { ActivityStatus, AdminMenus, type Alert, AnnotationRequired, type BaseProp, type BasfLayerItem, type BingNewsItem, CLUSTER_ACTIVITY_STATUS, type ClusterDto, ClusterFunding, ColorArray, ColorArrayCSSClass, type Colormap, type Column, Config, DOTS, type DefaultSettings, type DisplayItem, type Entry, FarmingSystem, Features, type FluffyThumbnail, type Font, type FooterSettings, type FundingSettings, type GlobalSettings, type Graphic, type HostInfo, HostService, HostType, HuntingManagement, ImageError, IsTokenExpired, type LabelPlacement, type Legend, type LegendInfo, type Line, type LinkWithNewTab, LiveStock, type LocationTasks, LookUps, MainAgriculturalAreas, MainCrops, type MainMenu, type MapLayer, type MapSettings, type Menu, type MenuItem, NewsDefaultImage, type NewsResult, OtherLandscapeElements, Permission, PermissionProvider, type Point, type Policy, type Polygon, type Provider, type ProviderImage, type PurpleThumbnail, QueryConstants, type QueryContext, QueryNames, QuestionnaireType, type Raster, ResourcesMenu, Responsive, type Rule, type Sort, StyleType, type SubMenu, type Symbolizer, TaskEventType, TaskState, TaskStatus, TaskStatusColor, type Text, USER_ROLE, type UtmResult, type ValueImage, ViewStatus, classNames, configStore, delayedSlideInUp, downloadData, downloadJSON, easing, findHostInfo, formatUnixDate, getButtonAppearance, getCmsUrlForHost, getContentWithSlug, getContentWithTypeAndDisplayName, getContentsWithType, getDefaultSettings, getGeoWikiSettings, getHostData, getHostFromRequest, getHtmlElementFromReactNode, getMediaUrl, getMenus, getPageContent, getPageProps, getTenantIdForHost, i18n, imageMaxDimension, imageMinDimension, itemVariants, keyStr, listVariants, rgbDataURL, routes, scrollToFirstErrorElement, settingsStore, shimmer, showIntroTour, slideInLeft, slideInRight, slideInUp, spring, toBase64, tokenData, trackAuthEvent, trackDownloadEvent, trackMapEvent, trackUmamiEvent, trackUserEvent, triplet, useAllNewsFromAllClusters, useApiImage, useApiUrl, useAppConfig, useAssignProjectToUser, useAssignableRoles, useAudience, useBasfStore, useBreadCrumbStore, useCluster, useClusterAllNews, useClusterDescription, useClusterDetails, useClusterFilterSettings, useClusterGetJoinRequests, useClusterGetNews, useClusterGetNewsNextPreviousStatus, useClusterImages, useClusterImagesAndVideos, useClusterLinks, useClusterMapInfo, useClusterNews, useClusterNewsWithId, useClusterOverview, useClusters, useCmsContentWithType, useCmsImage, useCmsUrl, useConfigSettings, useContractStatisticsByUser, useCountries, useCreateHost, useCurrentUser, useDefaultSettings, useDeleteHost, useDimensions, useEmailing, useEvolandBands, useEvolandLabels, useEvolandWmsLayers, useFeature, useFeatures, useFileUpload, useFileUrl, useFilterClusters, useGeoWikiSettings, useGetUserProject, useGrantedPolicies, useGroupsInProject, useHost, useHosts, useImageUrl, useIntroTourSettings, useIsAdmin, useIsAuthenticated, useIsInRole, useLanguages, useLatestTaskOnLocation, useLayerInfo, useLayerStore, useLocation, useLocationBulkUpload, useLocationsForProject, useLockBodyScroll, useLookUp, useMapMenuItems, useNews, useNewsFromAllClusters, usePagination, usePanelStore, usePermission, usePermissions, useProfile, useProjectDetails, useProjectResultSet, useProjectStatisticsByUser, useProjectUsers, useProjects, useProjectsPointsDownload, usePublicationSettings, useQuestionnaire, useRandomTasksPerLocation, useRenderInfo, useResource, useResourceFilter, useResourceType, useReviewTaskBulkUpload, useRoles, useTaskAnnotation, useTaskAnswers, useTaskBulkUpload, useTaskComments, useTaskDelete, useTaskMultipleAnnotations, useTaskSavedAnnotations, useTaskStatusList, useTasksPerLocation, useTenants, useTopic, useUpdateActiveGroupInProject, useUpdateHost, useUpdateUserDetail, useUserProfileGet, useUserRoles, useUsers };