jmapcloud-ng-core-types 0.0.4

package/index.ts

@@ -0,0 +1,1003 @@
+import { Feature, FeatureCollection, LineString, MultiLineString, Point, Polygon } from "geojson"
+import { Map } from "mapbox-gl"
+import { Store } from "redux"
+
+export interface JCoreService extends JCoreMainService {
+  Project: JProjectService
+  Layer: JLayerService
+  User: JUserService
+  Language: JLanguageService
+  Feature: JFeatureService
+  Map: JMapService
+  Geocoding: JGeocodingService
+  Geolocation: JGeolocationService
+  Geometry: JGeometryService
+  MouseOver: JMouseOverService
+  Form: JFormService
+  Query: JQueryService
+  Event: JEventService
+  History: JHistoryService
+  Extension: JExtensionService
+  Server: JServerService
+  Photo: JPhotoService
+  Util: JUtilService
+  Library: JLibraryService
+  Projection: JProjectionService
+  MapContext: JMapContextService
+  UI: JUIService
+}
+
+export interface JUIService {
+  setMainLayoutVisibility(isVisible: boolean): void
+  openIFramePopup(params: JIFramePopupParams): void
+  closeIFramePopup(): void
+  getContainerWidth(): number
+  getContainerHeight(): number
+}
+
+export interface JLibraryService {
+  mapboxgl(): any
+  html2canvas(): any
+}
+
+export interface JMapContextService {
+  isActive(): boolean
+  setActive(isActive: boolean): Promise<JMapContextSetActiveResult>
+  startCreation(): void
+  cancelCreation(): void
+  getAll(): JMapContext[]
+  getById(contextId: JId): JMapContext
+  existsById(contextId: JId): boolean
+  getUrlByUUID(contextUUID: string): string
+  applyContextById(contextId: JId): Promise<void>
+  deleteContextById(contextId: JId | JId[]): Promise<void>
+  create(params?: JMapContextMetaData): Promise<JMapContext>
+  update(contextId: JId, params?: JMapContextMetaData): Promise<JMapContext>
+  updateMetaData(contextId: JId, params: JMapContextMetaData): Promise<void>
+  setCreateTitle(newTitle: string): void
+  setCreateDescription(newDescription: string): void
+  setCreateTitleError(hasError: boolean): void
+  getContextTitle(contextId: JId): string
+  setContextTitle(contextId: JId, title: string): Promise<void>
+  getContextDescription(contextId: JId): string
+  setContextDescription(contextId: JId, description: string): Promise<void>
+  isLinkShared(contextId: JId): boolean
+  setLinkShare(contextId: JId, isShared: boolean): Promise<void>
+  getDefaultContext(): JMapContext | undefined
+  isDefaultContext(contextId: JId): boolean
+  setDefaultContext(contextId?: JId): Promise<void>
+  sortListBy(sortBy: JMAP_CONTEXT_SORT_BY_OPTIONS): void
+  getListSortBy(): JMAP_CONTEXT_SORT_BY_OPTIONS
+  getAllListSortBy(): JMAP_CONTEXT_SORT_BY_OPTIONS[]
+  setListSortDirection(sortByDirection: JMAP_CONTEXT_SORT_BY_DIRECTIONS): void
+  getListSortDirection(): JMAP_CONTEXT_SORT_BY_DIRECTIONS
+  getAllListSortDirection(): JMAP_CONTEXT_SORT_BY_DIRECTIONS[]
+  filterList(filter: string): void
+  getListFilter(): string
+  clearListFilter(): void
+  setPreviewImageSize(size: JSize): void
+  getPreviewImageSize(): JSize
+  addCssClassesToIgnoreForPreviewImage(classes: string[]): void
+  getIgnoredCssClassesForPreviewImage(): string[]
+}
+
+export interface JMapAttributionService {
+  getAll(): JMapAttribution[]
+  addSingle(attribution: JMapAttribution): void
+  addMultiple(attributions: JMapAttribution[]): void
+  removeByIds(attributionsIds: string[]): void
+  getById(attributionId: string): JMapAttribution
+  isDefaultAttributionId(attributionId: string): boolean
+}
+
+export interface JDateService {
+  getDate(date: JDateLike): Date
+  getDateFnsLocale(displayTime?: boolean): any
+  is12HoursTimeFormat(): boolean
+  getDateFromISOString(isoDate: string): Date
+  add(date: JDateLike, amount: number, timeUnit: JTIME_UNITS): Date
+  substract(date: JDateLike, amount: number, timeUnit: JTIME_UNITS): Date
+  format(date: JDateLike, params?: JDateFormatParams): string
+  formatDistanceToNow(date: JDateLike, params?: JDateFormatParams): string
+  isBefore(date1: JDateLike, date2: JDateLike, checkTime?: boolean): boolean
+  isAfter(date1: JDateLike, date2: JDateLike, checkTime?: boolean): boolean
+}
+
+export interface JUtilService {
+  Date: JDateService
+  LocalStorage: JLocalStorageService
+  Array: JArrayService
+  Ajax: JAjaxService
+  loadJSFile(fileUrl: string): Promise<void>
+  isJMapId(id: any, allowStringNumber?: boolean): boolean
+  checkJmapId(id: any, message?: string): void
+  getJmapIdAsIntegerIfPossible(id: any): JId
+  asyncProcess(callback: () => any, timeoutsInMilliseconds: number[]): () => void
+}
+
+export interface JArrayService {
+  clear<T>(array: T[]): T[]
+  remove<T>(array: T[], element: T): T[]
+  findByProperty<T extends object>(array: T[], propertyName: string, value: any): T | undefined
+  findIndexByProperty<T extends object>(array: T[], propertyName: string, value: any, nonStrict?: boolean): number
+  removeByProperty<T extends object>(array: T[], propertyName: string, value: any, nonStrict?: boolean): T[]
+  getCopyWithoutDuplicate(array: Array<string | number>): Array<string | number>
+}
+
+export interface JLocalStorageService {
+  isAvailable(): boolean
+  get(key: string): string | null
+  set(key: string, value: string): void
+  remove(key: string): void
+}
+
+export interface JPhotoService {
+  displayFeaturePhotosPopup(layerId: JId, featureId: JId): Promise<void>
+  displayPhotosPopup(photos: JPhoto[], params?: JPhotoOpenPopupParams): void
+  downloadById(photoId: JId): Promise<void>
+  closePhotoPopup(): void
+}
+
+export interface JFeatureService {
+  getById(layerId: JId, featureId: JId): Promise<GeoJSON.Feature>
+  getByIds(layerId: JId, featureIds: JId[]): Promise<GeoJSON.Feature[]>
+  geometryUpdateById(params: JFeatureGeometryUpdateParams): Promise<GeoJSON.Feature>
+  deleteById(layerId: JId, featureId: JId): Promise<GeoJSON.Feature>
+  deleteByIds(layerId: JId, featureIds: JId[]): Promise<JFeatureDeleteByIdsResult>
+}
+
+export interface JCoreMainService {
+  getVersion(): string
+  getApiVersion(): string
+  getDataStore(): Store<JCoreState> | undefined
+  getRestUrl(): string
+  openDocumentation(): void
+  getOS(): JOPERATING_SYSTEMS
+}
+
+export interface JGeocodingService {
+  isAvailable(): boolean
+  getMinimumSearchStringLength(): number
+  getInvalidSearchStringCharacters(): string
+  forwardSearch(searchText: string, options?: JGeocodingOptions): void
+  displayForwardSearchResult(forwardSearchResult: JGeocodingResult): void
+}
+
+export interface JGeolocationService {
+  isSupportedByBrowser(): boolean
+  isEnabled(): boolean
+  getMyLocation(): Promise<JLocation>
+  goToMyLocation(options?: JPanAndZoomOptions): Promise<JLocation>
+}
+
+export interface JQueryService {
+  initializeQueryFormById(layerId: JId, queryId: string): Promise<JQuery>
+  getAllGroups(): JQueryGroup[]
+  groupExist(groupId: JId): boolean
+  getQueriesByLayerId(layerId: JId): JQuery[]
+  getQueryByLayerId(layerId: JId, queryId: string): JQuery
+  getQueriesByGroupId(groupId: JId): JQuery[]
+  getQueryByGroupId(groupId: JId, queryId: string): JQuery
+  queryExist(groupId: JId, queryId: string): boolean
+  fetchFeatures(layerId: JId, queryId: string, data: any): Promise<Feature[]>
+}
+
+export interface JAjaxService {
+  get(config: JRequestConfig): Promise<any>
+  post(config: JRequestConfig): Promise<any>
+  put(config: JRequestConfig): Promise<any>
+  del(config: JRequestConfig): Promise<any>
+  patch(config: JRequestConfig): Promise<any>
+}
+
+export interface JEventService {
+  Main: JCoreEventModule
+  Layer: JLayerEventModule
+  Language: JLanguageEventModule
+  Map: JMapEventModule
+  Geocoding: JGeocodingEventModule
+  Photo: JPhotoEventModule
+  Project: JProjectEventModule
+  User: JUserEventModule
+  Feature: JFeatureEventModule
+  Form: JFormEventModule
+  Extension: JExtensionEventModule
+  MouseOver: JMouseOverEventModule
+  MapContext: JMapContextEventModule
+  Server: JServerEventModule
+  Query: JQueryEventModule
+}
+
+export type JEventFunction = (params?: any) => void | Promise<any>
+
+export interface JEventListener {
+  id: string
+  fn: JEventFunction
+}
+
+export type JEventSimpleListenerFunction = (listenerId: string, fn: JEventFunction) => void
+
+export type JEventResourceListenerFunction = (listenerId: string, resourceId: JId, fn: JEventFunction) => void
+
+export type JEventListenerFunction = JEventSimpleListenerFunction | JEventResourceListenerFunction
+
+export interface JEventModule {
+  on: {
+    [method: string]: JEventListenerFunction
+  }
+  existById(listenerId: string): boolean
+  activate(listenerId: string): void
+  deactivate(listenerId: string): void
+  remove(listenerId: string): void
+}
+
+export interface JQueryEventModule extends JEventModule {
+  on: {
+    queryFormLoad(listenerId: string, fn: (params: JQueryQueryFormHasLoadedEventParams) => void): void
+    beforeSubmit(listenerId: string, fn: (params: JQueryBeforeEventParams) => void): void
+    success(listenerId: string, fn: (params: JQuerySuccessEventParams) => void): void
+    error(listenerId: string, fn: (params: JQueryErrorEventParams) => void): void
+  }
+}
+
+export interface JServerEventModule extends JEventModule {
+  on: {
+    infoReady(listenerId: string, fn: (params: JServerInfoReadyEventParams) => void): void
+  }
+}
+
+export interface JFormEventModule extends JEventModule {
+  on: {
+    layerDialogOpened(listenerId: string, fn: (params: JFormLayerDialogOpenEventParams) => void): void
+    layerDialogClosed(listenerId: string, fn: (params: JFormLayerDialogCloseEventParams) => void): void
+    subFormDialogOpened(listenerId: string, fn: (params: JFormSubFormDialogOpenEventParams) => void): void
+    subFormDialogClosed(listenerId: string, fn: (params: JFormSubFormDialogCloseEventParams) => void): void
+    beforeSubmit(listenerId: string, fn: (params: JFormBeforeSubmitEventParams) => void | Promise<any>): void
+    submit(listenerId: string, fn: (params: JFormSubmitEventParams) => void): void
+  }
+}
+
+export interface JMouseOverEventModule extends JEventModule {
+  on: {
+    beforeContentProcessed(listenerId: string, fn: (params: JMouseOverBeforeEventParams) => void): void
+    afterContentProcessed(listenerId: string, fn: (params: JMouseOverAfterEventParams) => void): void
+    popupOpened(listenerId: string, fn: (params: JMouseOverEventParams) => void): void
+    popupClosed(listenerId: string, fn: () => void): void
+  }
+}
+
+export interface JExtensionEventModule extends JEventModule {
+  on: {
+    registration(listenerId: string, fn: (params: JExtensionEventParams) => void): void
+    beforeUnregistration(listenerId: string, fn: (params: JExtensionEventParams) => void): void
+    unregistration(listenerId: string, fn: (params: JExtensionEventParams) => void): void
+  }
+}
+
+export interface JProjectEventModule extends JEventModule {
+  on: {
+    projectChange(listenerId: string, fn: (params: JProjectEventParams) => void): void
+    projectsChange(listenerId: string, fn: (params: JProjectAllEventParams) => void): void
+    preDeactivation(listenerId: string, fn: (params: JProjectEventParams) => void): void
+    postDeactivation(listenerId: string, fn: (params: JProjectEventParams) => void): void
+  }
+}
+
+export interface JLanguageEventModule extends JEventModule {
+  on: {
+    localeChange(listenerId: string, fn: (params: JLanguageEventLocaleChangeParams) => void): void
+  }
+}
+
+export interface JGeocodingEventModule extends JEventModule {
+  on: {
+    success(listenerId: string, fn: (params: JGeocodingSuccessEventParams) => void): void
+    error(listenerId: string, fn: (params: JGeocodingErrorEventParams) => void): void
+  }
+}
+
+export interface JLayerEventModule extends JEventModule {
+  on: {
+    layersChange(listenerId: string, fn: (params: JLayerEventChangeParams) => void): void
+    thematicVisibilityChange(listenerId: string, fn: (params: JLayerEventThematicVisibilityParams) => void): void
+    thematicCategoriesVisibilityChange(
+      listenerId: string,
+      fn: (params: JLayerEventThematicCategoryVisibilityParams) => void
+    ): void
+    thematicConditionsVisibilityChange(
+      listenerId: string,
+      fn: (params: JLayerEventThematicConditionVisibilityParams) => void
+    ): void
+    visibilityChange(listenerId: string, fn: (params: JLayerEventVisibilityParams) => void): void
+    sourceChange(listenerId: string, fn: (params: JLayerEventParams) => void): void
+    selectabilityWillChange(listenerId: string, fn: (params: JLayerEventSelectabilityParams) => void): void
+    layerDeletion(listenerId: string, fn: (params: JLayerEventParams) => void): void
+    initialSearchApplied(listenerId: string, fn: (params: JLayerInitialSearchEventParams) => void): void
+    dynamicFilterSet(listenerId: string, fn: (params: JLayerDynamicFilterSetParams) => void): void
+    dynamicFilterActivationChange(listenerId: string, fn: (params: JLayerDynamicFilterActivationParams) => void): void
+    dynamicFilterConditionCreated(listenerId: string, fn: (params: JLayerDynamicFilterConditionCreated) => void): void
+    dynamicFilterConditionUpdated(listenerId: string, fn: (params: JLayerDynamicFilterConditionUpdated) => void): void
+    dynamicFilterConditionsRemoved(listenerId: string, fn: (params: JLayerDynamicFilterConditionsRemoved) => void): void
+  }
+}
+
+export interface JMapEventModule extends JEventModule {
+  on: {
+    mapLoad(listenerId: string, fn: (params: JMapEventLoadedParams) => void): void
+    mapDestroy(listenerId: string, fn: () => void): void
+    moveStart(listenerId: string, fn: (params: JMapEventParams) => void): void
+    move(listenerId: string, fn: (params: JMapEventParams) => void): void
+    moveEnd(listenerId: string, fn: (params: JMapEventParams) => void): void
+    mouseMove(listenerId: string, fn: (params: JMapEventLayerParams) => void): void
+    mouseMoveOnLayer(listenerId: string, layerId: JId, fn: (params: JMapEventFeaturesParams) => void): void
+    mouseEnterOnLayer(listenerId: string, layerId: JId, fn: (params: JMapEventFeaturesParams) => void): void
+    mouseLeaveOnLayer(listenerId: string, layerId: JId, fn: (params: JMapEventLayerParams) => void): void
+    click(listenerId: string, fn: (params: JMapEventLocationParams) => void): void
+    zoomStart(listenerId: string, fn: (params: JMapEventZoomParams) => void): void
+    zoom(listenerId: string, fn: (params: JMapEventZoomParams) => void): void
+    zoomEnd(listenerId: string, fn: (params: JMapEventZoomParams) => void): void
+    rotateStart(listenerId: string, fn: (params: JMapEventRotateParams) => void): void
+    rotate(listenerId: string, fn: (params: JMapEventRotateParams) => void): void
+    rotateEnd(listenerId: string, fn: (params: JMapEventRotateParams) => void): void
+    pitchStart(listenerId: string, fn: (params: JMapEventPitchParams) => void): void
+    pitch(listenerId: string, fn: (params: JMapEventPitchParams) => void): void
+    pitchEnd(listenerId: string, fn: (params: JMapEventPitchParams) => void): void
+    containerReady(listenerId: string, fn: (params: JMapEventContainerReadyParams) => void): void
+    containerResized(listenerId: string, fn: (params: JMapEventContainerResizedParams) => void): void
+    selectionChanged(listenerId: string, fn: (params: JMapEventSelectionChangedParams) => void): void
+    basemapChanged(listenerId: string, fn: (params: JMapEventBasemapChangedParams) => void): void
+  }
+}
+
+export interface JPhotoEventModule extends JEventModule {
+  on: {
+    containerCreated(listenerId: string, fn: (params: JPhotoEventContainerCreatedParams) => void): void
+  }
+}
+
+export interface JFeatureEventModule extends JEventModule {
+  on: {
+    deletion(listenerId: string, fn: (params: JFeatureEventDeleteParams) => void): void
+    geometryChanged(listenerId: string, fn: (params: JFeatureEventGeometryUpdateParams) => void): void
+    creation(listenerId: string, fn: (params: JFeatureEventCreateParams) => void): void
+  }
+}
+
+export interface JUserEventModule extends JEventModule {
+  on: {
+    sessionChanged(listenerId: string, fn: (params: JUserEventSessionChangedParams) => void): void
+  }
+}
+
+export interface JCoreEventModule extends JEventModule {
+  on: {
+    coreReady(listenerId: string, fn: () => void): void
+    fatalError(listenerId: string, fn: (params: JMainFatalErrorEventParams) => void): void
+  }
+}
+
+export interface JMapContextEventModule extends JEventModule {
+  on: {
+    beforeMapDataChange(listenerId: string, fn: (params: JMapContextBeforeMapDataChangeEventParams) => void): void
+    afterMapDataChange(listenerId: string, fn: (params: JMapContextAfterMapDataChangeEventParams) => void): void
+    beforeApply(listenerId: string, fn: (params: JMapContextBeforeApplyEventParams) => void): void
+    afterApply(listenerId: string, fn: (params: JMapContextAfterApplyEventParams) => void): void
+    applyError(listenerId: string, fn: (params: JMapContextEventParams) => void): void
+    initialized(listenerId: string, fn: (params: JMapContextSetActiveResult) => void): void
+  }
+}
+
+export interface JCoreState {
+  map: JMapState
+  project: JProjectState
+  layer: JLayerState
+  user: JUserState
+  language: JLanguageState
+  photo: JPhotoState
+  query: JQueryState
+  geocoding: JGeocodingState
+  geolocation: JGeolocationState
+  form: JFormState
+  server: JServerState
+  mapContext: JMapContextState
+  ui: JUIState
+  external?: any
+}
+
+export interface JUIState {
+  isMainLayoutVisible: boolean
+  iframePopup: JIFramePopup
+}
+
+export interface JMapContextState {
+  isInitialized: boolean
+  isActive: boolean
+  isLoading: boolean
+  hasLoadingError: boolean
+  isApplying: boolean
+  activeTab: JMAP_CONTEXT_TABS
+  contexts: JMapContext[]
+  defaultContextId: JId | undefined
+  filter: string
+  sortBy: JMAP_CONTEXT_SORT_BY_OPTIONS
+  sortByDirection: JMAP_CONTEXT_SORT_BY_DIRECTIONS
+  createTitle: string
+  createDescription: string
+  createTitleError: boolean
+}
+
+export interface JFormState {
+  layerId: JId // set as "" when no layer is set
+  formMetaDataById: JFormMetaDataById
+  isLoadingLayer: boolean
+  hasLoadingLayerError: boolean
+  isSubmitting: boolean
+  submitErrors: string[]
+  activeTabIndex: number
+  attributeForm: JForm | undefined
+  externalForms: JForm[]
+  subForms: JForm[]
+}
+
+export interface JGeocodingState {
+  isAvailable: boolean
+  isLoadPending: boolean
+  isLoading: boolean
+  hasLoadingError: boolean
+  searchString: string
+  results: JGeocodingResult[]
+}
+
+export interface JGeolocationState {
+  isLocationDisplayed: boolean
+  isEnabled: boolean
+  isSupported: boolean
+  currentLocation: JLocation | undefined
+}
+
+export interface JMapState {
+  pitch: number
+  rotation: number
+  bearing: number
+  isLoaded: boolean
+  hasFirstLoaded: boolean
+  hasLoadingError: boolean
+  navigationHistory: JMapNavigationStep[]
+  center: JLocation
+  zoom: number
+  scale: number
+  boundaryBox: JBoundaryBox
+  activeBasemapId: string | undefined
+  basemaps: JBasemap[]
+  selection: JMapSelection
+  jmapLayerIdsSupportedByMapbox: JId[]
+  scaleControlPosition: JMAP_POSITIONS
+  distanceUnit: JMAP_DISTANCE_UNITS
+  isNavigationHistoryControlVisible: boolean
+  isScaleControlVisible: boolean
+  isMapRotationControlVisible: boolean
+  isInfoControlVisible: boolean
+  isInfoControlExpanded: boolean
+  defaultZoomOptions: JZoomOptions
+  containerWidth: number
+  containerHeight: number
+  modificationType: JMAP_MODIFICATION_TYPES
+  attributions: JMapAttribution[]
+  rasterOpacityByLayerId: { [id: JId]: number }
+}
+
+export interface JProjectState {
+  isLoading: boolean
+  hasLoadingError: boolean
+  allProjects: JProject[]
+  selectedProject: JProject
+  disableProjectChange: boolean
+}
+
+export interface JLayerState {
+  isLoading: boolean
+  hasLoadingError: boolean
+  metadataSchema: JLayerMetadataSchemaItem[]
+  tree: JLayerTree
+  styleSamplesById: JLayerStyleSamplesById
+  allById: { [treeElementId: string]: JLayerTreeElement }
+  orderedLayerIds: JId[]
+  vectorLayerIds: JId[]
+}
+
+export interface JPhotoState {
+  selectedPhotoId: JId | undefined
+  photos: JPhoto[]
+  isPopupOpened: boolean
+  isLoading: boolean
+  hasLoadingError: boolean
+  isDownloading: boolean
+}
+
+export interface JQueryState {
+  groups: JQueryGroup[]
+  queriesByLayerId: { [key in JId]: JQuery[] }
+}
+
+export interface JUserState extends JTokenInfo {
+  isAnonymous: boolean
+  isLoggingIn: boolean
+  isLoggingIntoOrganization: boolean
+  isReloadingSession: boolean
+  identity: JUserIdentity
+  currentOrganization: JOrganization // the organization in which the user is currently logged in
+  organizationInfos: JOrganizationInfo[] // the info about all organizations the user belongs to
+  informations: JUserInfo[]
+  changePasswordAllowed: boolean
+}
+
+export interface JLanguageState {
+  locale: JLOCALES
+}
+
+export interface JServerState extends JServerInfo {
+  isReady: boolean
+  isLoading: boolean
+  hasLoadingError: boolean
+}
+
+export type JHistoryListener = (oldValue: string | undefined, newValue: string | undefined) => void
+
+export interface JFormService {
+  // REPO METHODS
+  getFormsMetaDataByLayerId(layerId: JId): Promise<JFormMetaData[]>
+  getElement(params: JFormElementId): Promise<JFormElement | undefined>
+  getElements(params: JFormElementIds): Promise<JFormElement[]>
+  getEntries(params: JFormGetEntriesParams): Promise<JFormElement[]>
+  createAttributeFormElement(params: JFormCreateAttributeFormElementParams): Promise<GeoJSON.Feature>
+  createDatabaseFormEntry(params: JFormCreateElementParams): Promise<JFormElement>
+  updateAttributeFormElements(params: JFormUpdateElementsParams): Promise<JFormResult[]>
+  updateDatabaseFormEntries(params: JFormUpdateElementsParams): Promise<JFormElement[]>
+  deleteDatabaseFormEntries(params: JFormElements): Promise<JDeleteEntriesResult>
+  // DIALOG METHODS (UI)
+  getAllFormsMetaDataForCurrentLayer(): JFormMetaData[]
+  getFormMetaDataByIdForCurrentLayer(formId: JId): JFormMetaData
+  hasDisplayedForm(): boolean
+  getDisplayedForm(): JForm
+  resetDisplayedForm(): void
+  setActiveTabIndex(tabIndex: number): void
+  getActiveTabIndex(): number
+  hasAttributeForm(): boolean
+  getAttributeForm(): JForm
+  getExternalForms(): JForm[]
+  getSubForms(): JForm[]
+  openCreationDialogForLayer(layerId: JId, geometry: GeoJSON.Geometry): Promise<JFormMetaData[]>
+  openUpdateDialogForLayer(layerId: JId, elements: JFormElement[]): Promise<JFormMetaData[]>
+  openCreationDialogForSubForm(subFormId: JId, selectedParentElements: JFormElement[]): JFormMetaData
+  openUpdateDialogForSubForm(subFormId: JId, subFormElements: JFormElement[]): JFormMetaData
+  closeCurrentDisplayedDialog(): void
+  getFormValues(form: JForm, initialData?: JAttributeValueByName): JAttributeValueByName
+  setFormValues(form: JForm, attributeValueByName: JAttributeValueByName): JFormErrors
+  submit(params?: JFormSubmitParams): Promise<JFormSubmitResult>
+  getNextViewId(): number
+  incrementNextViewId(): void
+  processRule(rule: any, data: any): any
+  canCreateElementOnForm(params: JFormId): boolean
+  canUpdateElementOnForm(params: JFormId): boolean
+  canDeleteElementOnForm(params: JFormId): boolean
+  hasEditOwnRightsForAllElements(params: JFormElements): boolean
+  isOwnPermissionRespectedForAllElements(layerId: JId, elements: JFormElement[]): boolean
+  // PHOTOS
+  hasDisplayedFormAPhotoField(): boolean
+  getDisplayedFormPhotos(): JPhoto[]
+  addDisplayedFormPhoto(photo: JPhoto): JId
+  updateDisplayedFormPhoto(params: JFormPhotoUpdate): void
+  removeDisplayedFormPhotoById(photoId: JId): void
+  // PURE FORM METHODS (not integrated, also used by query service)
+  checkAndCorrectSchemas(schema: JFormSchema, uiSchema: JFormUISchema): void
+  getDefaultValues(formMetaData: JFormMetaData, initialData?: JAttributeValueByName): JAttributeValueByName
+  getPreparedData(formMetaData: JFormMetaData, data: JAttributeValueByName): JAttributeValueByName
+  validateData(formMetaData: JFormMetaData, data: JAttributeValueByName): JFormErrors
+}
+
+export interface JHistoryService {
+  transformSearchParamsIntoHashParams(paramNames: string | string[]): void
+  goBack(): void
+  goForward(): void
+  getHashParameter(parameterName: string): string
+  getHashParameters(): { [key: string]: string }
+  pushHashParameters(parameterName: string, parameterValue: string): void
+  popHashParameters(parameterName: string): void
+  onParameterChange(parameterName: string, fn: JHistoryListener): string
+  removePropertyChangeListener(listenerId: string): void
+}
+
+export interface JGeometryService {
+  checkLocation(location: JLocation): void
+  isValidLocation(location: JLocation | undefined): boolean
+  isValidBbox(bbox: JBoundaryBox | undefined): boolean
+  getNormalizedBbox(bbox: JBoundaryBox, ogcCompliant: boolean): JBoundaryBox
+  isValidGeometry(geometry: any): boolean
+  checkCircle(circle: JCircle): void
+  checkPolygon(polygon: JPolygon): void
+  checkLine(line: JLine): void
+  checkBbox(bbox: JBoundaryBox): void
+  getArea(feature: Feature): number
+  getLineLength(
+    feature: Feature<LineString> | Feature<MultiLineString>,
+    units?: JGEOMETRY_UNITS | JMAP_DISTANCE_UNITS
+  ): number
+  getCentroid(feature: Feature | FeatureCollection): Feature<Point>
+  getFeatureFromLine(line: JLine): Feature<LineString>
+  getFeatureFromWkt(wkt: string): Feature
+  getPolygonFeatureFromCircle(circle: JCircle, units?: JGEOMETRY_UNITS): Feature<Polygon>
+  getFeatureFromPolygon(polygon: JPolygon): Feature<Polygon>
+  getBboxFromFeature(feature: Feature): JBoundaryBox
+  getBboxFromFeatures(features: Feature[]): JBoundaryBox
+  getBboxFromPolygon(polygon: JPolygon): JBoundaryBox
+  getBboxFromLine(line: JLine): JBoundaryBox
+  getPolygonFeatureFromBbox(boundaryBox: JBoundaryBox): Feature<Polygon>
+  bboxIntersect(bb1: JBoundaryBox, bb2: JBoundaryBox): boolean
+  polygonIntersect(feature1: Feature<Polygon>, feature2: Feature): boolean
+  lineIntersect(feature1: Feature<LineString>, feature2: Feature): boolean
+  getDistance(p1: JPoint | JLocation, p2: JPoint | JLocation): number // in km
+  getFeatureCollection(features: Feature[] | JLocation[] | JPoint[]): FeatureCollection
+  getCircleFeature(center: JPoint | JLocation, radius: number): Feature<Polygon> // radius in km
+  getPolygonFeature(coordinates: JPoint[], closeCoordinates?: boolean): Feature<Polygon>
+  isGeometryTypeValidForLayer(layerId: JId, geometryType: GeoJSON.GeoJsonGeometryTypes): boolean
+  getRotatedFeature(feature: GeoJSON.Feature, angle: number): GeoJSON.Feature
+  convertLength(length: number, toUnit: JMAP_DISTANCE_UNITS, fromUnit?: JMAP_DISTANCE_UNITS): number // fromUnit is km by default
+  convertArea(area: number, toUnit: JMAP_DISTANCE_UNITS, fromUnit?: JMAP_DISTANCE_UNITS): number // fromUnit is km by default
+}
+
+export interface JMapService {
+  Interaction: JMapInteractionService
+  Filter: JMapFilterService
+  Selection: JMapSelectionService
+  Basemap: JMapBasemapService
+  Attribution: JMapAttributionService
+  getMap(): Map
+  getMapJSLib(): any
+  getDomContainerId(): string
+  getAllDistanceUnits(): JMAP_DISTANCE_UNITS[]
+  getDistanceUnit(): JMAP_DISTANCE_UNITS
+  setDistanceUnit(distanceUnit: JMAP_DISTANCE_UNITS): void
+  isMapCreated(): boolean
+  isMapLoaded(): boolean
+  getExtent(): JBoundaryBox
+  getCenter(): { x: number; y: number }
+  getZoom(): number
+  getMapBoxSourceIdByJMapLayerId(layerId: JId): string
+  isScaleControlVisible(): boolean
+  setScaleControlVisibility(isVisible: boolean, position?: JMAP_POSITIONS): void
+  setScaleControlUnits(units: "imperial" | "metric" | "nautical"): void
+  setScaleControlPosition(position: JMAP_POSITIONS): void
+  getScaleControlPosition(): JMAP_POSITIONS
+  isNavigationHistoryControlVisible(): boolean
+  setNavigationHistoryControlVisibility(isVisible: boolean): void
+  isMapRotationControlVisible(): boolean
+  setMapRotationControlVisibility(isVisible: boolean): void
+  isMapInfoControlVisible(): boolean
+  setMapInfoControlVisibility(isVisible: boolean): void
+  isMapInfoControlExpanded(): boolean
+  setMapInfoControlExpansion(isExpanded: boolean): void
+  isLayerRendered(layerId: JId): boolean
+  getLayersVisibilityStatus(): JMapLayersVisibilityStatus
+  getLayersVisibilityStatusAsArray(): JMapLayerVisibilityStatus[]
+  getMapboxSupportedJMapLayerIds(): JId[]
+  getMapboxSupportedJMapLayerBefore(layerId: JId): JId | undefined
+  getMapboxSupportedJMapLayerAfter(layerId: JId): JId | undefined
+  refreshLayerById(layerId: JId): void
+  getRenderedJMapLayerIds(): JId[]
+  getRenderedFeatures(layerId: JId, params?: JLocation | JBoundaryBox | JCircle | JGetRenderedFeaturesParams): Feature[]
+  getSourceFeatures(layerId: JId, params?: JGetSourceFeaturesParams): Feature[]
+  getRenderedFeaturesAttributeValues(
+    layerId: JId,
+    filter?: JLocation | JBoundaryBox | JCircle
+  ): JMapFeatureAttributeValues[]
+  getPitch(): number
+  getRotation(): number
+  getBearing(): number
+  getNavigationHistoryStack(): JMapNavigationStep[]
+  undoLastNavigationStep(): JMapNavigationStep | undefined
+  setPitch(pitch: number): void
+  setRotation(rotation: number): void
+  setBearing(bearing: number): void
+  panTo(center: JLocation, stopJMapEventPropagation?: boolean): void
+  zoomTo(zoom: number, options?: JPanAndZoomOptions): void
+  zoomToRect(bbox: JBoundaryBox, options?: JPanAndZoomOptions): void
+  panAndZoomTo(center: JLocation, zoom: number, options?: JPanAndZoomOptions): void
+  setDefaultZoomOptions(options?: Partial<JZoomOptions>): void
+  navigateTo(params: JMapNavigateToParams): void
+  fitFeatures(features: Feature[], options?: JPanAndZoomOptions): void
+  flashLocation(location: JLocation, options?: JMapFlashLocationParams): void
+  flashLocations(locations: JLocation[], options?: JMapFlashLocationParams): void
+  clearFlashingLocations(): void
+  displayLayerExtent(layerId: JId, params?: JDisplayExtentParams): Promise<boolean>
+  displayExtent(extent: JBoundaryBox, params?: JDisplayExtentParams): void
+  getResolution(params?: JLatitudeAndZoom): number
+  getScale(params?: JLatitudeAndZoom): string
+  getScaleDenominator(params?: JLatitudeAndZoom): number
+  setScale(scaleDenominator: number, options?: JPanAndZoomOptions): number
+  getZoomFromScale(scaleDenominator: number, latitude?: number): number
+  getMouseCursor(): string
+  setMouseCursor(cursor: string): void
+  openModificationPopupForCenter(): void
+  openModificationPopupForScale(): void
+  closeModificationPopup(): void
+  getRasterLayerTransparency(layerId: JId): number
+  getRasterLayerInitialTransparency(layerId: JId): number
+  resetRasterLayerTransparency(layerId: JId): number
+  setRasterLayerTransparency(layerId: JId, transparency: number): void
+  applyCurrentPixelRatio(): Promise<void>
+  isPixelRatioCurrentlyValid(pixelRatio: number): boolean
+}
+
+export interface JMapBasemapService {
+  getAllIds(): string[]
+  isDisabled(): boolean
+  isActive(): boolean
+  isMapboxId(basemapId: string): boolean
+  isOSMId(basemapId: string): boolean
+  getActiveId(): string | undefined
+  existsById(basemapId: string): boolean
+  getById(basemapId: string): JBasemap
+  activateById(basemapId: string | undefined): void
+  deactivate(): void
+  add(basemap: JBasemap, activate?: boolean, beforeId?: string): void
+  removeById(basemapId: string): void
+  removeByIds(basemapIds: string[]): void
+}
+
+export interface JMapInteractionService {
+  addInteractor(name: string, interactor: JMapInteractor, active?: boolean): void
+  terminateInteractorById(interactorId: string): void
+  getAllInteractorIds(): string[]
+  getActiveInteractorId(): string
+  activateInteractorById(interactorId: string, force?: boolean): void
+}
+
+export interface JMapSelectionService {
+  isEmpty(): boolean
+  isEmptyByLayerId(layerId: JId): boolean
+  getSelectionCentroid(selection: JMapSelection): JLocation
+  getSelectedFeatures(): JMapSelection
+  getSelectedFeaturesForLayer(layerId: JId): Feature[]
+  getSelectedFeatureIdsForLayer(layerId: JId): string[]
+  selectOnOneLayerAtLocation(layerId: JId, location: JLocation, params?: JMapSelectionParams | undefined): Feature[]
+  selectOnOneLayerFromCircle(layerId: JId, circle: JCircle, params?: JMapSelectionParams | undefined): Feature[]
+  selectOnOneLayerFromLine(layerId: JId, line: JLine, params?: JMapSelectionParams | undefined): Feature[]
+  selectOnOneLayerFromPolygon(layerId: JId, polygon: JPolygon, params?: JMapSelectionParams | undefined): Feature[]
+  selectOnAllLayersAtLocation(location: JLocation, params?: JMapSelectionParams | undefined): JMapSelection
+  selectOnAllLayersFromCircle(circle: JCircle, params?: JMapSelectionParams | undefined): JMapSelection
+  selectOnAllLayersFromLine(line: JLine, params?: JMapSelectionParams | undefined): JMapSelection
+  selectOnAllLayersFromPolygon(polygon: JPolygon, params?: JMapSelectionParams | undefined): JMapSelection
+  setLayerSelection(layerId: JId, features: Feature | Feature[]): void
+  setLayersSelection(params: JSelectionSetLayersSelectionParams[]): void
+  addFeaturesToLayerSelection(layerId: JId, features: Feature | Feature[]): void
+  removeFeaturesFromLayerSelection(layerId: JId, featureIds: JId | JId[]): void
+  clearSelection(layerId?: JId): void
+  clearLayersSelection(layerIds: JId[]): void
+}
+
+export interface JMapFilterService {
+  applyHasAttribute(layerId: JId, attributeId: string): string
+  applyHasNotAttribute(layerId: JId, attributeId: string): string
+  applyAttributeValueEqualTo(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueBetween(layerId: JId, attributeId: string, start: any, end: any): string
+  applyAttributeValueNotEqualTo(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueGreaterThan(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueGreaterOrEqualsTo(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueLowerThan(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueLowerOrEqualsTo(layerId: JId, attributeId: string, attributeValue: any): string
+  applyAttributeValueIn(layerId: JId, attributeId: string, attributeValues: any[]): string
+  applyAttributeValueNotIn(layerId: JId, attributeId: string, attributeValues: any[]): string
+  applySpatial(layerId: JId, filterGeometry: JPolygon | JCircle): string
+  removeByFilterId(filterId: string): void
+  removeAllFilters(layerId: JId): void
+}
+
+export interface JProjectionService {
+  reprojectLocation(location: JLocation, toProjection: string, fromProjection?: string): JLocation
+  reprojectBoundaryBox(boundaryBox: JBoundaryBox, toProjection: string, fromProjection?: string): JBoundaryBox
+}
+
+export interface JProjectService {
+  hasProjectActivated(): boolean
+  getActiveProject(): JProject
+  activateById(projectId: JId): JProject
+  activateByName(projectName: string): JProject
+  deactivate(): void
+  getAllProjects(): Promise<JProject[]>
+  existsById(projectId: JId): boolean
+  existsByName(projectName: string): boolean
+  getById(projectId: JId): JProject
+  getByName(projectName: string): JProject
+  getId(): JId
+  getName(): string
+  getDescription(): string
+  getProjection(): JProjection
+  getDefaultDistanceUnit(): JMAP_DISTANCE_UNITS
+  getMapUnit(): JMAP_DISTANCE_UNITS
+  getInitialRotation(): number
+  getSelectionColor(): string
+  getBackgroundColor(): string
+  getInitialExtent(): JBounds | null
+  getBase64ImageThumbnail(): string
+  loadAllProjectThumbnails(params?: JProjectLoadThumbnailsParams): Promise<void>
+  isChangeDisabled(): boolean
+  setChangeEnabled(): void
+  setChangeDisabled(): void
+}
+
+export interface JLayerService {
+  Search: JLayerSearchService
+  Thematic: JLayerThematicService
+  DynamicFilter: JDynamicFilterService
+  getMetadataSchema(): JLayerMetadataSchemaItem[]
+  getLayerTree(): JLayerTree
+  getLayerTreeElementsById(): { [key in JId]: JLayerTreeElement }
+  getLayers(): JLayer[]
+  getLayerIds(): JId[]
+  getVectorLayers(): JLayer[]
+  getVectorLayerIds(): JId[]
+  getLayerAttributes(layerId: JId): JLayerAttribute[]
+  getLayerAttribute(layerId: JId, attributeName: string): JLayerAttribute
+  exists(layerId: JId): boolean
+  attributeExists(layerId: JId, attributeName: string): boolean
+  getById(layerId: JId): JLayerTreeElement
+  getSelfOrChildren(layerId: JId): JLayer[]
+  getName(layerId: JId): string
+  getDescription(layerId: JId): string
+  getEPSG4326Extent(layerId: JId): Promise<JBoundaryBox | null>
+  isVisible(layerId: JId, checkParentVisibility?: boolean): boolean
+  isVectorLayerById(layerId: JId): boolean
+  isSelectableById(layerId: JId): boolean
+  setSelectabilityById(layerId: JId, selectability: boolean, ignoreVisibility?: boolean): void
+  setLayersSelectability(params: JLayerSetLayersSelectabilityParams[]): void
+  isAllLayerParentsVisible(layerId: JId): boolean
+  setVisible(layerId: JId, visible: boolean): void
+  setLayersVisibility(params: JLayerSetLayersVisibilityParams[]): void
+  ensureLayerIsVisible(layerId: JId): void
+  ensureLayersAreVisible(layerIds: JId[]): void
+  setLayerGroupExpansion(layerGroupId: JId, isExpanded: boolean): void
+  setLayerGroupsExpansion(params: JLayerSetLayerGroupsExpansionParams[]): void
+  deleteLayer(layerId: JId): void
+  hasInformationReport(layerId: JId): boolean
+  openInformationReportInNewTab(layerId: JId, featureIds: JId[]): Promise<string>
+}
+
+export interface JLayerSearchService {
+  byAttribute(params: JLayerSearchByAttributesParams): Promise<Feature[]>
+}
+
+export interface JLayerThematicService {
+  getAllByLayerId(layerId: JId): JLayerThematic[]
+  getById(layerId: JId, thematicId: JId): JLayerThematic
+  existsById(layerId: JId, thematicId: JId): boolean
+  hasAnyVisibleByLayerId(layerId: JId): boolean
+  getAllVisibleByLayerId(layerId: JId): JLayerThematic[]
+  setVisibilityById(layerId: JId, thematicId: JId, visibility: boolean): void
+  setThematicsVisibility(params: JLayerThematicSetVisibilityParams[]): void
+  setCategoryVisibility(params: JLayerThematicSetCategoryVisibilityParams): void
+  setAllCategoriesVisibility(layerId: JId, thematicId: JId, visibility: boolean): void
+  setConditionVisibility(params: JLayerThematicSetConditionVisibilityParams): void
+  setAllConditionsVisibility(layerId: JId, thematicId: JId, visibility: boolean): void
+  getFamilyTypeById(layerId: JId, thematicId: JId): JLAYER_THEMATIC_FAMILY_TYPES
+}
+
+export interface JUserService {
+  getToken(): string
+  getOrganization(): JOrganization
+  getFullName(): string
+  getUsername(): string
+  getPreference(name: string): Promise<string | null>
+  hasPreference(name: string): Promise<boolean>
+  removePreference(name: string): Promise<string | null>
+  setPreference(name: string, value: string | undefined): Promise<void>
+  setToken(token: string, organizationId?: string): Promise<JSessionData>
+  login(login: string, password: string): Promise<JSessionData>
+  loginIntoOrganization(organizationId: string): Promise<JSessionData>
+  loginWithIdentityProvider(providerId: string): void
+  logout(): Promise<void>
+  isLoggedIn(): boolean
+  getAllInfos(): JUserInfo[]
+  addInfo(info: JUserInfo): void
+  removeInfo(infoId: string): void
+  changePassword(newPassword: string, currentPassword: string): Promise<void>
+  changeFullName(newFullName: string): Promise<void>
+  getMinimumPasswordLength(): number
+  isPasswordCompliant(password: string): boolean
+  getPasswordPolicyCompliance(
+    password: string
+  ): JJMapServerPasswordPolicyCompliance | JJMapCloudPasswordPolicyCompliance
+  isPseudoUser(): boolean
+  getOrganizationId(): string
+}
+
+export interface JLanguageService {
+  addBundle(bundle: JTranslationBundle): void
+  bundleExitsById(bundleId: string): boolean
+  getBundleById(bundleId: string): JTranslationBundle
+  getAllBundleIds(): string[]
+  getBundles(): JTranslationBundleById
+  getLocales(): JLOCALES[]
+  getLocale(): JLOCALES
+  getDateFnsLocale(displayTime?: boolean): any
+  getDefaultLocale(): JLOCALES
+  setLocale(locale: JLOCALES): void
+  translate(params: JTranslateParams): string
+  is12HoursTimeFormat(): boolean
+  isValidLocale(locale: JLOCALES): boolean
+  getDateFnsDateFormat(): string
+}
+
+export interface JMouseOverService {
+  isPopupOpened(): boolean
+  closePopup(): void
+  openPopup(params: JMouseOverOpenPopupParams): void
+  openPopupForSelection(params: JMouseOverOpenPopupForSelectionParams): void
+  renderForFeaturesAtLocation(containerId: string, location: JLocation): boolean // return true if has mouseover
+  renderForFeaturesSelection(containerId: string, selection: JMapSelection): boolean // return true if has mouseover
+  openInformationReportInNewTab(layerId: JId): Promise<string>
+}
+
+export interface JExtensionService {
+  register(extension: JCoreExtension): void
+  isRegistered(extensionId: string): boolean
+  getAllRegisteredIds(): string[]
+  hasMouseOver(): boolean
+  renderMouseOver(layer: JLayer, feature: Feature): Array<JExtensionMouseOver | undefined>
+}
+
+export interface JServerService {
+  isReady(): boolean
+  getVersion(): JServerVersion
+  getType(): JSERVER_TYPES
+  isSaas(): boolean
+  isLegacy(): boolean
+  getMinimumVersion(): JMinimumServerVersion
+  isMinimumVersionRespected(serverInfo?: JServerInfo): boolean
+  getShortVersion(): string
+  isStandardLoginAvailable(): boolean
+  getIdentityProviderById(providerId: string): JServerAnyIdentityProvider
+  getAllIdentityProvidersById(): JServerIdentityProviderById
+}
+
+export interface JDynamicFilterService {
+  isAvailable(layerId: JId): boolean
+  isActive(layerId: JId): boolean
+  setIsActive(layerId: JId, isActive: boolean): void
+  getByLayerId(layerId: JId): JDynamicFilter
+  getAllOperators(): JLAYER_DYNAMIC_FILTER_OPERATORS[]
+  getAllMultipleValuesOperators(): JLAYER_DYNAMIC_FILTER_OPERATORS[]
+  getAllTwoValuesOperators(): JLAYER_DYNAMIC_FILTER_OPERATORS[]
+  getOperatorsForAttributeType(attributeType: JLAYER_ATTRIBUTE_TYPES): JLAYER_DYNAMIC_FILTER_OPERATORS[]
+  getConditionError(condition: JDynamicFilterCondition): string | undefined
+  isConditionValid(condition: JDynamicFilterCondition): boolean
+  existSimilarCondition(condition: JDynamicFilterCondition, isUpdate?: boolean): boolean
+  set(params: JDynamicFilterSetParams[]): void
+  createCondition(condition: JDynamicFilterCondition): number
+  updateCondition(condition: JDynamicFilterCondition): void
+  removeConditions(layerId: JId, conditionsIds: number[]): void
+  isNoValueOperator(operator: JLAYER_DYNAMIC_FILTER_OPERATORS): boolean
+  isMultipleValuesOperator(operator: JLAYER_DYNAMIC_FILTER_OPERATORS): boolean
+  isTwoValuesOperator(operator: JLAYER_DYNAMIC_FILTER_OPERATORS): boolean
+  getConditionValueError(
+    operator: JLAYER_DYNAMIC_FILTER_OPERATORS,
+    attributeType: JLAYER_ATTRIBUTE_TYPES,
+    value?: any
+  ): string | undefined
+  isConditionValueValid(
+    operator: JLAYER_DYNAMIC_FILTER_OPERATORS,
+    attributeType: JLAYER_ATTRIBUTE_TYPES,
+    value?: any
+  ): boolean
+  canAttributeTypeAcceptMultipleValuesOperators(attributeType: JLAYER_ATTRIBUTE_TYPES): boolean
+  canAttributeTypeAcceptTwoValuesOperators(attributeType: JLAYER_ATTRIBUTE_TYPES): boolean
+  getIsBetweenValuesError(attributeType: JLAYER_ATTRIBUTE_TYPES, value1: any, value2: any): string | undefined
+  getNowValue(): string
+  getAllLastOperatorUnits(): string[]
+}
+
+// MISC
+export interface JObjectId {
+  project: string
+  layer: string
+  element: string
+}