diff --git a/packages/client/src/api.tsx b/packages/client/src/api.tsx
index 150e72a1f..364af95d7 100644
--- a/packages/client/src/api.tsx
+++ b/packages/client/src/api.tsx
@@ -21,7 +21,10 @@ import {
   IUser,
   Relation,
   RequestPermissionUpdate,
+  IRequestStats,
+  IAudit,
 } from "@shared/types";
+import { ISetting, ISettingGroup } from "@shared/types/settings";
 import * as errors from "@shared/types/errors";
 import { NetworkError } from "@shared/types/errors";
 import { IRequestSearch } from "@shared/types/request-search";
@@ -674,7 +677,8 @@ class Api {
     entityIds: string[],
     options?: IApiOptions
   ): Promise<(EntitiesDeleteSuccessResponse | EntitiesDeleteErrorResponse)[]> {
-    const out: (EntitiesDeleteSuccessResponse | EntitiesDeleteErrorResponse)[] = [];
+    const out: (EntitiesDeleteSuccessResponse | EntitiesDeleteErrorResponse)[] =
+      [];
     try {
       const response = await this.connection.delete(`/entities/`, {
         data: {
@@ -682,13 +686,21 @@ class Api {
         },
         ...options,
       });
-      const data = (response.data as IResponseGeneric<Record<string, errors.CustomError | true>>).data;
+      const data = (
+        response.data as IResponseGeneric<
+          Record<string, errors.CustomError | true>
+        >
+      ).data;
       if (data) {
         for (const errorEntityId of Object.keys(data)) {
           if (data[errorEntityId] === true) {
             out.push({ entityId: errorEntityId, details: data[errorEntityId] });
           } else {
-            out.push({ entityId: errorEntityId, error: true, details: data[errorEntityId] });
+            out.push({
+              entityId: errorEntityId,
+              error: true,
+              details: data[errorEntityId],
+            });
           }
         }
       }
@@ -851,6 +863,21 @@ class Api {
     }
   }
 
+  /**
+   * Stats
+   */
+  async statsGet(
+    data: IRequestStats,
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseAudit>> {
+    try {
+      const response = await this.connection.post(`/stats`, data, options);
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
   /**
    * Audit
    */
@@ -869,6 +896,20 @@ class Api {
     }
   }
 
+  async auditGetFirst(
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric<IAudit>>> {
+    try {
+      const response = await this.connection.get(
+        `/audits?skip=0&take=1&from=1970`,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
   /**
    * Statement
    * Editor container
@@ -1218,6 +1259,40 @@ class Api {
     }
   }
 
+  async documentRemoveAnchors(
+    documentId: string,
+    entityId: string,
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric>> {
+    try {
+      const response = await this.connection.patch(
+        `/documents/${documentId}/removeAnchors?entityId=${entityId}`,
+        document,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  async documentRemoveAnchor(
+    documentId: string,
+    entityId: string,
+    anchorText: string,
+    anchorIndex: number,
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric>> {
+    try {
+      // todo add api endpoint
+
+      // @ts-ignore
+      return null;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
   /**
    * Document update
    */
@@ -1237,6 +1312,113 @@ class Api {
       throw this.handleError(err);
     }
   }
+
+  /**
+   * Setting get
+   * @param settingId
+   * @param options
+   * @returns
+   */
+  async settingGet(
+    settingId: string,
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric<ISetting>>> {
+    try {
+      const response = await this.connection.get(
+        `/settings/${settingId}`,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  /**
+   * Setting group get
+   * @param settingId
+   * @param options
+   * @returns
+   */
+  async settingGroupGet(
+    settingGroupId: string,
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric<ISettingGroup>>> {
+    try {
+      const response = await this.connection.get(
+        `/settings/group/${settingGroupId}`,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  /**
+   * Setting group get
+   * @param settingId
+   * @param data
+   * @param options
+   * @returns
+   */
+  async settingGroupUpdate(
+    settingGroupId: string,
+    data: { id: string; value: unknown }[],
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric<ISettingGroup>>> {
+    try {
+      const response = await this.connection.put(
+        `/settings/group/${settingGroupId}`,
+        data,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  /**
+   * Setting update
+   * @param settingId
+   * @param data
+   * @param options
+   * @returns
+   */
+  async settingUpdate(
+    settingId: string,
+    data: { value: unknown },
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric>> {
+    try {
+      const response = await this.connection.put(
+        `/settings/${settingId}`,
+        data,
+        options
+      );
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  /**
+   * Get owner's info
+   * @param settingId
+   * @param options
+   * @returns
+   */
+  async usersGetOwner(
+    options?: IApiOptions
+  ): Promise<AxiosResponse<IResponseGeneric<string>>> {
+    try {
+      const response = await this.connection.get(`/users/owner`, options);
+      return response;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
 }
 
 const apiSingleton = new Api();
diff --git a/packages/client/src/components/advanced/Annotator/Annotator.tsx b/packages/client/src/components/advanced/Annotator/Annotator.tsx
index ade26754a..15706a007 100644
--- a/packages/client/src/components/advanced/Annotator/Annotator.tsx
+++ b/packages/client/src/components/advanced/Annotator/Annotator.tsx
@@ -539,7 +539,7 @@ export const TextAnnotator = ({
       </StyledCanvasWrapper>
 
       {annotator && (
-        <ButtonGroup $marginTop={true}>
+        <ButtonGroup $marginTop>
           <Button
             key={EditMode.HIGHLIGHT}
             icon={<FaPen size={11} />}
diff --git a/packages/client/src/components/advanced/DocumentModal/DocumentModalEdit.tsx b/packages/client/src/components/advanced/DocumentModal/DocumentModalEdit.tsx
index b4cc3dd5f..7c010c861 100644
--- a/packages/client/src/components/advanced/DocumentModal/DocumentModalEdit.tsx
+++ b/packages/client/src/components/advanced/DocumentModal/DocumentModalEdit.tsx
@@ -1,25 +1,31 @@
-import React, { useEffect, useRef, useState } from "react";
+import React, { useEffect, useState } from "react";
 
-import { Modal, ModalContent, ModalFooter, ModalHeader } from "components";
-import { IResponseDocument } from "@shared/types";
+import { IDocument, IDocumentMeta, IResponseDocument } from "@shared/types";
+import { Modal, ModalContent, ModalHeader } from "components";
 import { useWindowSize } from "hooks/useWindowSize";
 import { getShortLabelByLetterCount } from "utils/utils";
 import TextAnnotator from "../Annotator/Annotator";
 import AnnotatorProvider from "../Annotator/AnnotatorProvider";
+import { Annotator } from "@inkvisitor/annotator/src/lib";
 
-interface DocumentModal {
-  document: IResponseDocument | undefined;
+interface DocumentModalEdit {
+  document: IResponseDocument | IDocumentMeta | IDocument | undefined;
   onClose: () => void;
+  anchor?: { entityId: string; occurence?: number };
 }
-const DocumentModalEdit: React.FC<DocumentModal> = ({ onClose, document }) => {
+const DocumentModalEdit: React.FC<DocumentModalEdit> = ({
+  onClose,
+  document,
+  anchor,
+}) => {
   const [show, setShow] = useState(false);
-
   useEffect(() => {
     setShow(true);
   }, []);
-
   const [windowWidth, windowHeight] = useWindowSize();
 
+  // const [annotatorInitialized, setAnnotatorInitialized] = useState(false);
+
   return (
     <Modal width={1000} showModal={show} onClose={onClose} fullHeight>
       <ModalHeader
@@ -39,21 +45,21 @@ const DocumentModalEdit: React.FC<DocumentModal> = ({ onClose, document }) => {
               width={965}
               height={windowHeight - 180}
               displayLineNumbers={true}
+              hlEntities={[]}
+              storedAnnotatorScroll={0}
+              forwardAnnotator={(newAnnotator) => {
+                // if (!annotatorInitialized && newAnnotator && anchor?.entityId) {
+                anchor?.entityId &&
+                  newAnnotator?.scrollToAnchor(anchor?.entityId);
+                // setAnnotatorInitialized(true);
+                // }
+              }}
             />
           </AnnotatorProvider>
         ) : (
           <div>Document not found</div>
         )}
       </ModalContent>
-      {/* <ModalFooter>
-        <div
-          style={{
-            display: "flex",
-            justifyContent: "space-between",
-            width: "100%",
-          }}
-        ></div>
-      </ModalFooter> */}
     </Modal>
   );
 };
diff --git a/packages/client/src/components/advanced/EntityTag/EntityTag.tsx b/packages/client/src/components/advanced/EntityTag/EntityTag.tsx
index dbcc7b4ff..21786d9c3 100644
--- a/packages/client/src/components/advanced/EntityTag/EntityTag.tsx
+++ b/packages/client/src/components/advanced/EntityTag/EntityTag.tsx
@@ -72,6 +72,9 @@ export const EntityTag: React.FC<EntityTag> = ({
   const draggedEntity: DraggedEntityReduxItem = useAppSelector(
     (state) => state.draggedEntity
   );
+  if (entity === undefined) {
+    return null;
+  }
 
   if (!entity) {
     return null;
diff --git a/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModal.tsx b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModal.tsx
new file mode 100644
index 000000000..6d0aaeca7
--- /dev/null
+++ b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModal.tsx
@@ -0,0 +1,329 @@
+import {
+  EProtocolTieType,
+  ITerritoryValidation,
+} from "@shared/types/territory";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import api from "api";
+import {
+  Button,
+  ButtonGroup,
+  Loader,
+  Modal,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  Submit,
+} from "components";
+import { ValidationRule } from "components/advanced";
+import React, { useEffect, useMemo, useState } from "react";
+import { FaPlus, FaToggleOff, FaToggleOn } from "react-icons/fa";
+import { rootTerritoryId } from "Theme/constants";
+import {
+  StyledBlockSeparator,
+  StyledGridForm,
+  StyledGridFormLabel,
+  StyledGridSectionHeading,
+  StyledSectionHeader,
+  StyledToggleWrap,
+  StyledValidationCount,
+  StyledValidationList,
+} from "./GlobalValidationsModalStyles";
+import { deepCopy } from "utils/utils";
+import { IEntity } from "@shared/types";
+import { useSearchParams } from "hooks";
+import {
+  entityKeys,
+  territoryKeys,
+  valencyKeys,
+  globalValidationsDict,
+  ValidationKey,
+} from "@shared/enums/warning";
+import { GlobalValidationsSettingsRow } from "./GlobalValidationsSettingsRow";
+import { ISetting } from "@shared/types/settings";
+import { toast } from "react-toastify";
+
+const initialRulesState: Record<ValidationKey, boolean> = Object.keys(
+  globalValidationsDict
+).reduce((acc, key) => {
+  acc[key as ValidationKey] = true;
+  return acc;
+}, {} as Record<ValidationKey, boolean>);
+
+const initValidation: ITerritoryValidation = {
+  detail: "",
+  entityClasses: [],
+  classifications: [],
+  allowedEntities: [],
+  allowedClasses: [],
+  propType: [],
+  tieType: EProtocolTieType.Property,
+};
+
+interface GlobalValidationsModal {
+  setShowGlobalValidations: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export const GlobalValidationsModal: React.FC<GlobalValidationsModal> = ({
+  setShowGlobalValidations,
+}) => {
+  const [showModal, setShowModal] = useState(false);
+  useEffect(() => {
+    setShowModal(true);
+  }, []);
+
+  const {
+    status,
+    data: rootTerritory,
+    error: entityError,
+    isFetching,
+  } = useQuery({
+    queryKey: ["entity", rootTerritoryId],
+    queryFn: async () => {
+      const res = await api.detailGet(rootTerritoryId);
+      return res.data;
+    },
+    enabled: api.isLoggedIn(),
+  });
+
+  const {
+    status: settingsStatus,
+    data: settings,
+    error: settingsError,
+    isFetching: settingsIsFetching,
+  } = useQuery({
+    queryKey: ["settings"],
+    queryFn: async () => {
+      const res = await api.settingGroupGet("validations");
+      return res.data.data?.settings;
+    },
+    enabled: api.isLoggedIn(),
+  });
+
+  const validations = rootTerritory?.data.validations || [];
+
+  const queryClient = useQueryClient();
+
+  const updateEntityMutation = useMutation({
+    mutationFn: async (changes: Partial<IEntity>) =>
+      await api.entityUpdate(rootTerritoryId, changes),
+
+    onSuccess: (data, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["entity"] });
+    },
+  });
+
+  const updateSettingsMutation = useMutation({
+    mutationFn: async (newSettings: Omit<ISetting, "public">[]) =>
+      await api.settingGroupUpdate("validations", newSettings),
+
+    onSuccess: (data, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["settings"] });
+      toast.success("settings updated");
+    },
+  });
+
+  const [tempIndexToRemove, setTempIndexToRemove] = useState<false | number>(
+    false
+  );
+
+  const initValidationRule = () => {
+    updateEntityMutation.mutate({
+      data: {
+        validations: validations
+          ? [...validations, initValidation]
+          : [initValidation],
+      },
+    });
+  };
+
+  const removeValidationRule = (indexToRemove: number) => {
+    updateEntityMutation.mutate({
+      data: {
+        validations: (validations as ITerritoryValidation[])?.filter(
+          (_, index) => index !== indexToRemove
+        ),
+      },
+    });
+    setTempIndexToRemove(false);
+  };
+
+  const handleUpdateValidation = (
+    key: number,
+    changes: Partial<ITerritoryValidation>
+  ) => {
+    const validationsCopy = deepCopy(validations as ITerritoryValidation[]);
+    const updatedObject: ITerritoryValidation = {
+      ...validationsCopy[key],
+      ...changes,
+    };
+    const newValidation = [
+      ...validationsCopy.slice(0, key),
+      updatedObject,
+      ...validationsCopy.slice(key + 1),
+    ];
+    updateEntityMutation.mutate({
+      data: {
+        validations: newValidation,
+      },
+    });
+  };
+
+  const [rules, setRules] =
+    useState<Record<ValidationKey, boolean>>(initialRulesState);
+
+  const settingsKeyValue = useMemo(
+    () =>
+      settings?.reduce((acc, setting) => {
+        acc[setting.id as ValidationKey] = setting.value as boolean;
+        return acc;
+      }, {} as Record<ValidationKey, boolean>),
+    [settings]
+  );
+
+  useEffect(() => {
+    if (settingsKeyValue) {
+      setRules(settingsKeyValue);
+    }
+  }, [JSON.stringify(settingsKeyValue)]);
+
+  const toggleRule = (key: ValidationKey) => {
+    setRules((prev) => ({ ...prev, [key]: !prev[key] }));
+  };
+
+  return (
+    <>
+      <Modal
+        showModal={showModal}
+        onClose={() => setShowGlobalValidations(false)}
+        width={650}
+      >
+        <ModalHeader
+          title="Global validations"
+          boldTitle
+          onClose={() => setShowGlobalValidations(false)}
+        />
+        <ModalContent column enableScroll>
+          <StyledGridForm>
+            <StyledGridSectionHeading>
+              Valency validations
+            </StyledGridSectionHeading>
+            <div />
+            {valencyKeys.map((val, key) => (
+              <GlobalValidationsSettingsRow
+                key={key}
+                validation={val}
+                active={rules[val]}
+                toggleRule={() => toggleRule(val)}
+              />
+            ))}
+
+            <StyledGridSectionHeading>
+              Entity validations
+            </StyledGridSectionHeading>
+            <div />
+            {entityKeys.map((val, key) => (
+              <GlobalValidationsSettingsRow
+                key={key}
+                validation={val}
+                active={rules[val]}
+                toggleRule={() => toggleRule(val)}
+              />
+            ))}
+
+            <StyledGridSectionHeading>
+              Territory validations
+            </StyledGridSectionHeading>
+            <div />
+            {territoryKeys.map((val, key) => (
+              <GlobalValidationsSettingsRow
+                key={key}
+                validation={val}
+                active={rules[val]}
+                toggleRule={() => toggleRule(val)}
+              />
+            ))}
+          </StyledGridForm>
+
+          {rootTerritory && (
+            <>
+              <StyledSectionHeader>
+                <b>Root T validation</b>
+                <StyledValidationCount>{`${validations?.length} Root T validations`}</StyledValidationCount>
+                <span>
+                  <Button
+                    icon={<FaPlus />}
+                    label="new validation rule"
+                    color="primary"
+                    onClick={initValidationRule}
+                  />
+                </span>
+              </StyledSectionHeader>
+              <StyledValidationList>
+                {(validations as ITerritoryValidation[])?.map(
+                  (validation, key) => {
+                    return (
+                      <React.Fragment key={key}>
+                        <ValidationRule
+                          key={key}
+                          validation={validation}
+                          entities={rootTerritory.entities}
+                          updateValidationRule={(
+                            changes: Partial<ITerritoryValidation>
+                          ) => {
+                            handleUpdateValidation(key, changes);
+                          }}
+                          removeValidationRule={() => {
+                            setTempIndexToRemove(key);
+                          }}
+                          isInsideTemplate={false}
+                          userCanEdit
+                        />
+                        {key !== validations.length - 1 && (
+                          <StyledBlockSeparator />
+                        )}
+                      </React.Fragment>
+                    );
+                  }
+                )}
+              </StyledValidationList>
+            </>
+          )}
+
+          <Loader show={isFetching || updateEntityMutation.isPending} />
+        </ModalContent>
+        <ModalFooter>
+          <ButtonGroup>
+            <Button
+              color="warning"
+              label="cancel"
+              onClick={() => setShowGlobalValidations(false)}
+            />
+            <Button
+              color="primary"
+              label="submit"
+              disabled={
+                JSON.stringify(settingsKeyValue) === JSON.stringify(rules)
+              }
+              onClick={() => {
+                const newSettings: Omit<ISetting, "public">[] = Object.entries(
+                  rules
+                ).map(([id, value]) => ({ id, value }));
+                updateSettingsMutation.mutate(newSettings);
+              }}
+            />
+          </ButtonGroup>
+        </ModalFooter>
+      </Modal>
+
+      <Submit
+        show={tempIndexToRemove !== false}
+        title="Remove validation rule"
+        text="Do you really want to remove this validation rule?"
+        onSubmit={() => {
+          tempIndexToRemove !== false &&
+            removeValidationRule(tempIndexToRemove);
+        }}
+        onCancel={() => setTempIndexToRemove(false)}
+      />
+    </>
+  );
+};
diff --git a/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModalStyles.tsx b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModalStyles.tsx
new file mode 100644
index 000000000..ff4b471d7
--- /dev/null
+++ b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsModalStyles.tsx
@@ -0,0 +1,68 @@
+import styled from "styled-components";
+
+export const StyledGridForm = styled.div`
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 1rem;
+  align-items: center;
+  margin-left: 0.8rem;
+  margin-bottom: 2.5rem;
+`;
+export const StyledGridSectionHeading = styled.div`
+  display: grid;
+  justify-content: end;
+  align-items: center;
+  font-weight: ${({ theme }) => theme.fontWeight["bold"]};
+  margin-top: 1rem;
+`;
+interface StyledGridFormLabel {
+  $disabled: boolean;
+  ref: React.Dispatch<React.SetStateAction<HTMLButtonElement | null>>;
+}
+export const StyledGridFormLabel = styled.div<StyledGridFormLabel>`
+  display: grid;
+  justify-content: end;
+  align-items: center;
+  color: ${({ theme, $disabled }) => ($disabled ? theme.color["greyer"] : "")};
+`;
+export const StyledValidationList = styled.div`
+  display: flex;
+  flex-direction: column;
+  row-gap: 1.5rem;
+`;
+export const StyledBlockSeparator = styled.div`
+  width: 100%;
+  grid-column: span 2;
+  border-top: 1px dashed grey;
+`;
+interface StyledToggleWrap {
+  $active: boolean;
+  $disabled: boolean;
+}
+export const StyledToggleWrap = styled.div<StyledToggleWrap>`
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  color: ${({ theme, $active, $disabled }) =>
+    $disabled
+      ? theme.color["greyer"]
+      : $active
+      ? theme.color["info"]
+      : theme.color["danger"]};
+  cursor: ${({ $disabled }) => ($disabled ? "not-allowed" : "pointer")};
+`;
+
+export const StyledSectionHeader = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  font-weight: ${({ theme }) => theme.fontWeight.regular};
+  font-size: ${({ theme }) => theme.fontSize.lg};
+  margin-bottom: ${({ theme }) => theme.space[4]};
+  color: ${({ theme }) => theme.color["primary"]};
+`;
+
+export const StyledValidationCount = styled.p`
+  color: ${({ theme }) => theme.color["info"]};
+  font-size: ${({ theme }) => theme.fontSize["sm"]};
+`;
diff --git a/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsSettingsRow.tsx b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsSettingsRow.tsx
new file mode 100644
index 000000000..4f75f7921
--- /dev/null
+++ b/packages/client/src/components/advanced/GlobalValidationsModal/GlobalValidationsSettingsRow.tsx
@@ -0,0 +1,69 @@
+import {
+  globalValidationsDict,
+  ValidationKey,
+  WarningKey,
+  WarningTypeEnums,
+} from "@shared/enums/warning";
+import React, { useState } from "react";
+import {
+  StyledGridFormLabel,
+  StyledToggleWrap,
+} from "./GlobalValidationsModalStyles";
+import { FaToggleOn, FaToggleOff } from "react-icons/fa";
+import { Tooltip } from "components";
+
+interface GlobalValidationsSettingsRow {
+  validation: ValidationKey;
+  active: boolean;
+  toggleRule: () => void;
+}
+export const GlobalValidationsSettingsRow: React.FC<
+  GlobalValidationsSettingsRow
+> = ({ validation, active, toggleRule }) => {
+  const [referenceElement, setReferenceElement] =
+    useState<HTMLButtonElement | null>(null);
+  const [showTooltip, setShowTooltip] = useState(false);
+  const tooltipLabel = globalValidationsDict[validation].label;
+  const tooltipContent = globalValidationsDict[validation].description;
+
+  const isDisabled = !globalValidationsDict[validation].editAllowed;
+  return (
+    <>
+      <StyledGridFormLabel
+        ref={setReferenceElement}
+        onMouseEnter={() => setShowTooltip(true)}
+        onMouseLeave={() => setShowTooltip(false)}
+        $disabled={isDisabled}
+      >
+        {globalValidationsDict[validation].label}
+      </StyledGridFormLabel>
+      <div>
+        <StyledToggleWrap
+          $active={active}
+          $disabled={isDisabled}
+          onClick={() => !isDisabled && toggleRule()}
+        >
+          {active ? (
+            <>
+              <FaToggleOn size={22} /> active
+            </>
+          ) : (
+            <>
+              <FaToggleOff size={22} /> inactive
+            </>
+          )}
+        </StyledToggleWrap>
+      </div>
+
+      {tooltipContent && (
+        <Tooltip
+          label={tooltipLabel}
+          content={<p>{tooltipContent}</p>}
+          visible={showTooltip}
+          referenceElement={referenceElement}
+          // position={tooltipPosition}
+        />
+      )}
+    </>
+  );
+};
diff --git a/packages/client/src/components/advanced/Menu/Menu.tsx b/packages/client/src/components/advanced/Menu/Menu.tsx
index ac714cb86..bf920f0e0 100644
--- a/packages/client/src/components/advanced/Menu/Menu.tsx
+++ b/packages/client/src/components/advanced/Menu/Menu.tsx
@@ -92,7 +92,12 @@ export const Menu: React.FC<Menu> = ({
         <StyledMenuGroupWrapper>
           <StyledMenuGroup>
             {pages
-              .filter((p) => !p.admin || userRole === UserEnums.Role.Admin)
+              .filter(
+                (p) =>
+                  !p.admin ||
+                  userRole === UserEnums.Role.Admin ||
+                  userRole === UserEnums.Role.Owner
+              )
               .map((page, key) => (
                 <MenuItem
                   key={key}
diff --git a/packages/client/src/components/advanced/Page/Page.tsx b/packages/client/src/components/advanced/Page/Page.tsx
index 7e251dd0c..55c975d5d 100644
--- a/packages/client/src/components/advanced/Page/Page.tsx
+++ b/packages/client/src/components/advanced/Page/Page.tsx
@@ -19,6 +19,7 @@ import { setUsername } from "redux/features/usernameSlice";
 import { useAppDispatch, useAppSelector } from "redux/hooks";
 import { ThemeColor } from "Theme/theme";
 import { StyledPage, StyledPageContent } from "./PageStyles";
+import { UserEnums } from "@shared/enums";
 
 interface Page {
   children?: React.ReactNode;
@@ -30,7 +31,7 @@ export const Page: React.FC<Page> = ({ children }) => {
     (state) => state.statementList.lastClickedIndex
   );
   const userId = localStorage.getItem("userid");
-  const userRole = localStorage.getItem("userrole");
+  const userRole = localStorage.getItem("userrole") as UserEnums.Role;
   const { cleanAllParams } = useSearchParams();
 
   const layoutWidth: number = useAppSelector(
diff --git a/packages/client/src/components/advanced/PageHeader/PageHeader.tsx b/packages/client/src/components/advanced/PageHeader/PageHeader.tsx
index 7fc2bc2d9..9fcac28b1 100644
--- a/packages/client/src/components/advanced/PageHeader/PageHeader.tsx
+++ b/packages/client/src/components/advanced/PageHeader/PageHeader.tsx
@@ -1,38 +1,41 @@
+import { InterfaceEnums, UserEnums } from "@shared/enums";
 import { useQueryClient } from "@tanstack/react-query";
 import { heightHeader } from "Theme/constants";
 import { PingColor } from "Theme/theme";
 import LogoInkvisitor from "assets/logos/inkvisitor.svg";
-import { Loader } from "components";
+import { Button, Loader } from "components";
 import React, { useEffect, useState } from "react";
+import { MdDarkMode, MdSunny } from "react-icons/md";
 import { useLocation, useNavigate } from "react-router";
 import { BeatLoader } from "react-spinners";
 import { toast } from "react-toastify";
+import { setTheme } from "redux/features/themeSlice";
 import { useAppDispatch, useAppSelector } from "redux/hooks";
+import { getUserIcon } from "utils/utils";
 import { Menu } from "..";
 import packageJson from "../../../../package.json";
 import {
-  StyledFaUserAlt,
   StyledFlexColumn,
   StyledFlexRow,
   StyledHeader,
   StyledHeaderLogo,
   StyledHeaderTag,
+  StyledLoggedAsWrap,
+  StyledMenu,
   StyledPingColor,
   StyledPingText,
   StyledRightHeader,
   StyledSandboxText,
   StyledSpace,
   StyledText,
-  StyledUser,
-  StyledUsername,
   StyledThemeSwitcher,
   StyledThemeSwitcherIcon,
-  StyledMenu,
-  StyledLoggedAsWrap,
+  StyledUser,
+  StyledUserIconWrap,
+  StyledUsername,
 } from "./PageHeaderStyles";
-import { setTheme } from "redux/features/themeSlice";
-import { MdDarkMode, MdSunny } from "react-icons/md";
-import { InterfaceEnums } from "@shared/enums";
+import { IoSettingsSharp } from "react-icons/io5";
+import { GlobalValidationsModal } from "../GlobalValidationsModal/GlobalValidationsModal";
 
 interface LeftHeader {
   tempLocation: string | false;
@@ -147,7 +150,7 @@ export const LeftHeader: React.FC<LeftHeader> = React.memo(
 interface RightHeader {
   setUserCustomizationOpen: (arg0: boolean) => void;
   userName: string;
-  userRole: string;
+  userRole: UserEnums.Role;
   tempLocation: string | false;
   setTempLocation: React.Dispatch<React.SetStateAction<string | false>>;
   handleLogOut: () => void;
@@ -181,6 +184,8 @@ export const RightHeader: React.FC<RightHeader> = React.memo(
 
     const usernameLoaded = userName.length > 0;
 
+    const [showGlobalValidations, setShowGlobalValidations] = useState(true);
+
     return (
       <>
         {env === "sandbox" && (
@@ -215,14 +220,36 @@ export const RightHeader: React.FC<RightHeader> = React.memo(
             </StyledThemeSwitcherIcon>
           </StyledThemeSwitcher>
 
+          {userRole === UserEnums.Role.Owner && (
+            <div
+              style={{
+                display: "flex",
+                alignItems: "center",
+                marginRight: "1rem",
+              }}
+            >
+              <Button
+                radiusLeft
+                radiusRight
+                label="global validations"
+                icon={<IoSettingsSharp />}
+                onClick={() => setShowGlobalValidations(true)}
+                color="greyer"
+                inverted
+              />
+            </div>
+          )}
+
           <StyledLoggedAsWrap>
             {userName.length > 0 && (
               <StyledUser>
                 <StyledText>logged as</StyledText>
-                <StyledFaUserAlt
-                  size={14}
+
+                <StyledUserIconWrap
                   onClick={() => setUserCustomizationOpen(true)}
-                />
+                >
+                  {getUserIcon(userRole, 19)}
+                </StyledUserIconWrap>
                 <StyledUsername onClick={() => setUserCustomizationOpen(true)}>
                   {userName}
                 </StyledUsername>
@@ -243,6 +270,12 @@ export const RightHeader: React.FC<RightHeader> = React.memo(
             />
           </StyledMenu>
         </StyledRightHeader>
+
+        {showGlobalValidations && (
+          <GlobalValidationsModal
+            setShowGlobalValidations={setShowGlobalValidations}
+          />
+        )}
       </>
     );
   }
diff --git a/packages/client/src/components/advanced/PageHeader/PageHeaderStyles.tsx b/packages/client/src/components/advanced/PageHeader/PageHeaderStyles.tsx
index 97605f1b6..094094a95 100644
--- a/packages/client/src/components/advanced/PageHeader/PageHeaderStyles.tsx
+++ b/packages/client/src/components/advanced/PageHeader/PageHeaderStyles.tsx
@@ -24,10 +24,10 @@ export const StyledHeaderTag = styled.div`
   padding-bottom: 0;
 `;
 
-export const StyledFaUserAlt = styled(FaUserAlt)`
+export const StyledUserIconWrap = styled.div`
   cursor: pointer;
   margin-left: ${({ theme }) => theme.space[2]};
-  margin-right: ${({ theme }) => theme.space[1]};
+  margin-right: ${({ theme }) => theme.space[2]};
 `;
 export const StyledText = styled.div`
   font-size: ${({ theme }) => theme.fontSize["sm"]};
diff --git a/packages/client/src/components/advanced/UserCustomizationModal/UserCustomizationModal.tsx b/packages/client/src/components/advanced/UserCustomizationModal/UserCustomizationModal.tsx
index 8af8ec25a..17c2eaa9f 100644
--- a/packages/client/src/components/advanced/UserCustomizationModal/UserCustomizationModal.tsx
+++ b/packages/client/src/components/advanced/UserCustomizationModal/UserCustomizationModal.tsx
@@ -396,6 +396,12 @@ export const UserCustomizationModal: React.FC<UserCustomizationModal> = ({
                         selected: role === userRoleDict[2].value,
                         onClick: () => {},
                       },
+                      {
+                        longValue: userRoleDict[3].label,
+                        shortValue: userRoleDict[3].label,
+                        selected: role === userRoleDict[3].value,
+                        onClick: () => {},
+                      },
                     ]}
                   />
                 </div>
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRule.tsx b/packages/client/src/components/advanced/ValidationRule/ValidationRule.tsx
similarity index 96%
rename from packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRule.tsx
rename to packages/client/src/components/advanced/ValidationRule/ValidationRule.tsx
index a84d268c5..04bf0e7a1 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRule.tsx
+++ b/packages/client/src/components/advanced/ValidationRule/ValidationRule.tsx
@@ -6,7 +6,7 @@ import {
   EProtocolTieType,
   ITerritoryValidation,
 } from "@shared/types/territory";
-import { Button, Checkbox, Input } from "components";
+import { Button, Input } from "components";
 import Dropdown, {
   AttributeButtonGroup,
   EntitySuggester,
@@ -20,21 +20,19 @@ import {
   StyledGrid,
   StyledLabel,
   StyledNotActiveTag,
-} from "./EntityDetailValidationRuleStyles";
-import { EntityDetailValidationText } from "./EntityDetailValidationText/EntityDetailValidationText";
+} from "./ValidationRuleStyles";
+import { ValidationText } from "./ValidationText/ValidationText";
 
-interface EntityDetailValidationRule {
+interface ValidationRule {
   validation: ITerritoryValidation;
   entities: Record<string, IEntity>;
   updateValidationRule: (changes: Partial<ITerritoryValidation>) => void;
   removeValidationRule: () => void;
   isInsideTemplate: boolean;
-  territoryParentId: string | undefined;
+  territoryParentId?: string;
   userCanEdit: boolean;
 }
-export const EntityDetailValidationRule: React.FC<
-  EntityDetailValidationRule
-> = ({
+export const ValidationRule: React.FC<ValidationRule> = ({
   validation,
   entities,
   updateValidationRule,
@@ -99,7 +97,7 @@ export const EntityDetailValidationRule: React.FC<
         }}
       >
         {!active && <StyledNotActiveTag>rule not activated</StyledNotActiveTag>}
-        <EntityDetailValidationText
+        <ValidationText
           validation={validation}
           entities={entities}
           active={active}
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRuleStyles.tsx b/packages/client/src/components/advanced/ValidationRule/ValidationRuleStyles.tsx
similarity index 100%
rename from packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRuleStyles.tsx
rename to packages/client/src/components/advanced/ValidationRule/ValidationRuleStyles.tsx
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationText/EntityDetailValidationText.tsx b/packages/client/src/components/advanced/ValidationRule/ValidationText/ValidationText.tsx
similarity index 94%
rename from packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationText/EntityDetailValidationText.tsx
rename to packages/client/src/components/advanced/ValidationRule/ValidationText/ValidationText.tsx
index 3069f5a35..97efff5f3 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationText/EntityDetailValidationText.tsx
+++ b/packages/client/src/components/advanced/ValidationRule/ValidationText/ValidationText.tsx
@@ -7,20 +7,19 @@ import {
 } from "@shared/types/territory";
 import React, { useCallback, useMemo } from "react";
 import { getEntityLabel } from "utils/utils";
-import {
-  StyledSentence,
-  StyledSentenceEntity,
-} from "../EntityDetailValidationRuleStyles";
+import { StyledSentence, StyledSentenceEntity } from "../ValidationRuleStyles";
 
-interface EntityDetailValidationText {
+interface ValidationText {
   validation: ITerritoryValidation;
   entities: Record<string, IEntity>;
   active: boolean;
 }
 
-export const EntityDetailValidationText: React.FC<
-  EntityDetailValidationText
-> = ({ validation, entities, active }) => {
+export const ValidationText: React.FC<ValidationText> = ({
+  validation,
+  entities,
+  active,
+}) => {
   const {
     detail,
     entityClasses,
diff --git a/packages/client/src/components/advanced/index.tsx b/packages/client/src/components/advanced/index.tsx
index ac0cb66c9..70e1c1bdd 100644
--- a/packages/client/src/components/advanced/index.tsx
+++ b/packages/client/src/components/advanced/index.tsx
@@ -26,6 +26,7 @@ import { LeftHeader, RightHeader } from "./PageHeader/PageHeader";
 import { PanelSeparator } from "./PanelSeparator/PanelSeparator";
 import { TerritoryActionModal } from "./TerritoryActionModal/TerritoryActionModal";
 import { UserCustomizationModal } from "./UserCustomizationModal/UserCustomizationModal";
+import { ValidationRule } from "./ValidationRule/ValidationRule";
 
 const Dropdown = {
   Single: {
@@ -61,6 +62,7 @@ export {
   PanelSeparator,
   TerritoryActionModal,
   UserCustomizationModal,
+  ValidationRule,
   ElvlButtonGroup,
   MoodVariantButtonGroup,
   PositionButtonGroup,
diff --git a/packages/client/src/components/basic/DocumentTitle/DocumentTitle.tsx b/packages/client/src/components/basic/DocumentTitle/DocumentTitle.tsx
new file mode 100644
index 000000000..8eb6ca218
--- /dev/null
+++ b/packages/client/src/components/basic/DocumentTitle/DocumentTitle.tsx
@@ -0,0 +1,19 @@
+import React from "react";
+import { TiDocumentText } from "react-icons/ti";
+import { StyledDocumentTag, StyledDocumentTitle } from "./DocumentTitleStyles";
+
+interface DocumentTitle {
+  title?: string;
+}
+export const DocumentTitle: React.FC<DocumentTitle> = ({ title = "" }) => {
+  return (
+    <>
+      <StyledDocumentTag>
+        <TiDocumentText style={{ marginRight: "0.2rem", flexShrink: "0" }} />
+        <div style={{ display: "grid" }}>
+          <StyledDocumentTitle>{title}</StyledDocumentTitle>
+        </div>
+      </StyledDocumentTag>
+    </>
+  );
+};
diff --git a/packages/client/src/components/basic/DocumentTitle/DocumentTitleStyles.tsx b/packages/client/src/components/basic/DocumentTitle/DocumentTitleStyles.tsx
new file mode 100644
index 000000000..d45a44424
--- /dev/null
+++ b/packages/client/src/components/basic/DocumentTitle/DocumentTitleStyles.tsx
@@ -0,0 +1,20 @@
+import styled from "styled-components";
+
+export const StyledDocumentTag = styled.div`
+  display: inline-flex;
+  margin: 0 0.6rem;
+  background-color: ${({ theme }) => theme.color["blue"][400]};
+  padding: ${({ theme }) => theme.space[1] + " " + theme.space[3]};
+  border-radius: ${({ theme }) => theme.borderRadius["md"]};
+  color: white;
+  font-size: small;
+  align-items: center;
+`;
+
+export const StyledDocumentTitle = styled.p`
+  display: inline-block;
+  vertical-align: middle;
+  white-space: nowrap;
+  overflow: hidden !important;
+  text-overflow: ellipsis;
+`;
diff --git a/packages/client/src/components/basic/Message/Message.tsx b/packages/client/src/components/basic/Message/Message.tsx
index 85c1e6aa5..0de7f77cb 100644
--- a/packages/client/src/components/basic/Message/Message.tsx
+++ b/packages/client/src/components/basic/Message/Message.tsx
@@ -37,7 +37,7 @@ export const Message: React.FC<Message> = ({ warning, entities }) => {
     async function getEntities(eids: string[]) {
       const extractedEntities: Record<string, IEntity> = { ...entities };
       for (const eid of eids) {
-        const entityRes = await api.entitiesGet(eid);
+        const entityRes = await api.entitiesGet(eid).catch(() => undefined);
         if (entityRes?.data && !entities?.[eid]) {
           extractedEntities[eid] = entityRes.data;
         }
diff --git a/packages/client/src/components/basic/Modal/Modal.tsx b/packages/client/src/components/basic/Modal/Modal.tsx
index 92cdbc3f4..242df1366 100644
--- a/packages/client/src/components/basic/Modal/Modal.tsx
+++ b/packages/client/src/components/basic/Modal/Modal.tsx
@@ -105,18 +105,20 @@ interface ModalHeader {
   color?: keyof ThemeColor;
   icon?: React.ReactNode;
   onClose?: () => void;
+  boldTitle?: boolean;
 }
 export const ModalHeader: FC<ModalHeader> = ({
   title,
   color,
   icon,
   onClose,
+  boldTitle,
 }) => {
   return (
     <>
       <StyledCardHeader $color={color}>
         {icon && <StyledCardIcon>{icon}</StyledCardIcon>}
-        <StyledCardTitle>{title}</StyledCardTitle>
+        <StyledCardTitle $boldTitle={boldTitle}>{title}</StyledCardTitle>
         {onClose && (
           <StyledCloseIconWrap onClick={onClose}>
             <StyledIoClose size={20} />
diff --git a/packages/client/src/components/basic/Modal/ModalStyles.tsx b/packages/client/src/components/basic/Modal/ModalStyles.tsx
index a3dd39b0b..5c3f7fd2f 100644
--- a/packages/client/src/components/basic/Modal/ModalStyles.tsx
+++ b/packages/client/src/components/basic/Modal/ModalStyles.tsx
@@ -85,8 +85,12 @@ export const StyledCardIcon = styled.div`
   font-size: 24;
   margin-right: 0.5rem;
 `;
-export const StyledCardTitle = styled.h2`
-  font-weight: ${({ theme }) => theme.fontWeight["medium"]};
+interface StyledCardTitle {
+  $boldTitle?: boolean;
+}
+export const StyledCardTitle = styled.h2<StyledCardTitle>`
+  font-weight: ${({ theme, $boldTitle }) =>
+    $boldTitle ? theme.fontWeight["bold"] : theme.fontWeight["medium"]};
   font-size: ${({ theme }) => theme.fontSize["xl"]};
 `;
 interface StyledCardBody {
diff --git a/packages/client/src/components/basic/Tooltip/Tooltip.tsx b/packages/client/src/components/basic/Tooltip/Tooltip.tsx
index b36d2195f..78326e285 100644
--- a/packages/client/src/components/basic/Tooltip/Tooltip.tsx
+++ b/packages/client/src/components/basic/Tooltip/Tooltip.tsx
@@ -6,7 +6,7 @@ import {
   VirtualElement,
 } from "@popperjs/core";
 import { useSpring } from "@react-spring/web";
-import { ThemeColor } from "Theme/theme";
+import { ThemeColor, ThemeFontSize } from "Theme/theme";
 import React, { ReactElement, useEffect, useState } from "react";
 import { usePopper } from "react-popper";
 import {
diff --git a/packages/client/src/components/basic/Tooltip/TooltipStyles.tsx b/packages/client/src/components/basic/Tooltip/TooltipStyles.tsx
index d114690ae..2566edb01 100644
--- a/packages/client/src/components/basic/Tooltip/TooltipStyles.tsx
+++ b/packages/client/src/components/basic/Tooltip/TooltipStyles.tsx
@@ -1,5 +1,5 @@
 import { animated } from "@react-spring/web";
-import { ThemeColor } from "Theme/theme";
+import { ThemeColor, ThemeFontSize } from "Theme/theme";
 import styled from "styled-components";
 
 interface StyledContainer {
diff --git a/packages/client/src/components/index.tsx b/packages/client/src/components/index.tsx
index e9cdde3ad..edcd5506e 100644
--- a/packages/client/src/components/index.tsx
+++ b/packages/client/src/components/index.tsx
@@ -38,6 +38,7 @@ import { Tooltip } from "./basic/Tooltip/Tooltip";
 import { TypeBar } from "./basic/TypeBar/TypeBar";
 import { ContactAdminFooting } from "./basic/ContactAdminFooting/ContactAdminFooting";
 import { CustomScrollbar } from "./basic/CustomScrollbar/CustomScrollbar";
+import { DocumentTitle } from "./basic/DocumentTitle/DocumentTitle";
 
 export {
   AttributeIcon,
@@ -52,6 +53,7 @@ export {
   Cloud,
   CustomScrollbar,
   Dropzone,
+  DocumentTitle,
   Header,
   IconButtonGroup,
   IconFont,
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetail.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetail.tsx
index ca2bc6e91..d3b7596b2 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetail.tsx
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetail.tsx
@@ -64,6 +64,7 @@ import { EntityDetailStatementPropsTable } from "./EntityDetailUsedInTable/Entit
 import { EntityDetailStatementsTable } from "./EntityDetailUsedInTable/EntityDetailStatementsTable/EntityDetailStatementsTable";
 import { EntityDetailValency } from "./EntityDetailValency/EntityDetailValency";
 import { EntityDetailValidationSection } from "./EntityDetailValidationSection/EntityDetailValidationSection";
+import { EntityDetailUsedInDocumentsTable } from "./EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTable";
 
 const allowedEntityChangeClasses = [
   EntityEnums.Class.Value,
@@ -938,6 +939,18 @@ export const EntityDetail: React.FC<EntityDetail> = ({
                     perPage={10}
                   />
                 )}
+
+                {!entity.isTemplate && (
+                  <EntityDetailUsedInDocumentsTable
+                    title={{
+                      singular: "Anchor",
+                      plural: "Anchors",
+                    }}
+                    entities={entity.entities}
+                    useCases={entity.usedInDocuments}
+                    perPage={10}
+                  />
+                )}
               </StyledDetailSection>
 
               {/* Audits */}
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailProtocol/EntityDetailProtocol.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailProtocol/EntityDetailProtocol.tsx
index 5c089e212..99da928a2 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailProtocol/EntityDetailProtocol.tsx
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailProtocol/EntityDetailProtocol.tsx
@@ -13,7 +13,7 @@ import {
   StyledTagWrap,
   StyledValue,
 } from "./EntityDetailProtocolStyles";
-import { StyledFlexList } from "../EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationRuleStyles";
+import { StyledFlexList } from "../../../../../../components/advanced/ValidationRule/ValidationRuleStyles";
 
 const initialProtocol: ITerritoryProtocol = {
   project: "",
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailClassificationTable/EntityDetailClassificationTable.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailClassificationTable/EntityDetailClassificationTable.tsx
index 4f7284d5f..fedaa7a12 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailClassificationTable/EntityDetailClassificationTable.tsx
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailClassificationTable/EntityDetailClassificationTable.tsx
@@ -15,8 +15,8 @@ interface EntityDetailClassificationTable {
 }
 export const EntityDetailClassificationTable: React.FC<
   EntityDetailClassificationTable
-> = ({ title, entities, useCases, perPage = 5 }) => {
-  const data = useMemo(() => (useCases ? useCases : []), [useCases]);
+> = ({ title, entities, useCases = [], perPage = 5 }) => {
+  const data = useMemo(() => useCases, [useCases]);
 
   const columns = useMemo<Column<IResponseUsedInStatementClassification>[]>(
     () => [
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTable.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTable.tsx
new file mode 100644
index 000000000..2dd55748b
--- /dev/null
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTable.tsx
@@ -0,0 +1,151 @@
+import { IDocumentMeta, IEntity } from "@shared/types";
+import { IResponseUsedInDocument } from "@shared/types/response-detail";
+import { useMutation } from "@tanstack/react-query";
+import api from "api";
+import { DocumentTitle, Table } from "components";
+import { DocumentModalEdit, EntityTag } from "components/advanced";
+import React, { useMemo, useState } from "react";
+import { FaAnchor } from "react-icons/fa";
+import { HiClipboardList } from "react-icons/hi";
+import { CellProps, Column } from "react-table";
+import { toast } from "react-toastify";
+import {
+  StyledAbbreviatedLabel,
+  StyledAnchorText,
+} from "./EntityDetailUsedInDocumentsTableStyles";
+
+type CellType = CellProps<IResponseUsedInDocument>;
+interface EntityDetailUsedInDocumentsTable {
+  title: { singular: string; plural: string };
+  entities: { [key: string]: IEntity };
+  useCases: IResponseUsedInDocument[];
+  perPage?: number;
+}
+export const EntityDetailUsedInDocumentsTable: React.FC<
+  EntityDetailUsedInDocumentsTable
+> = ({ title, entities, useCases = [], perPage }) => {
+  const data = useMemo(() => useCases, [useCases]);
+
+  const removeAnchorMutation = useMutation({
+    mutationFn: (data: { documentId: string; entityId: string }) =>
+      api.documentRemoveAnchors(data.documentId, data.entityId),
+    onSuccess(data, variables, context) {},
+  });
+
+  const [openedDocument, setOpenedDocument] = useState<IDocumentMeta | false>(
+    false
+  );
+  const [tempAnchor, setTempAnchor] = useState<string | false>(false);
+
+  const columns = useMemo<Column<IResponseUsedInDocument>[]>(
+    () => [
+      {
+        Header: "Anchor text",
+        Cell: ({ row }: CellType) => {
+          const { anchorText } = row.original;
+          return (
+            <>
+              {anchorText ? (
+                <StyledAnchorText>
+                  <HiClipboardList
+                    size={18}
+                    style={{ cursor: "pointer" }}
+                    onClick={() => {
+                      window.navigator.clipboard.writeText(anchorText);
+                      toast.info("text copied to clipboard");
+                    }}
+                  />
+                  <StyledAbbreviatedLabel>
+                    {anchorText || ""}
+                  </StyledAbbreviatedLabel>
+                </StyledAnchorText>
+              ) : (
+                <></>
+              )}
+            </>
+          );
+        },
+      },
+      {
+        Header: "Resource",
+        Cell: ({ row }: CellType) => {
+          const resourceEntity = entities[row.original.resourceId];
+          return <>{resourceEntity && <EntityTag entity={resourceEntity} />}</>;
+        },
+      },
+      {
+        Header: "Document",
+        Cell: ({ row }: CellType) => {
+          const { document } = row.original;
+          return document ? <DocumentTitle title={document.title} /> : <></>;
+        },
+      },
+      {
+        Header: "Parent territory",
+        Cell: ({ row }: CellType) => {
+          const territoryEntity = entities[row.original.parentTerritoryId];
+          return (
+            <>
+              {territoryEntity && (
+                <EntityTag
+                  entity={territoryEntity}
+                  unlinkButton={{
+                    onClick: () => {
+                      setTempAnchor(territoryEntity.id);
+                      setOpenedDocument(row.original.document);
+                    },
+                    icon: <FaAnchor />,
+                    tooltipLabel: "open anchor",
+                  }}
+                />
+              )}
+            </>
+          );
+        },
+      },
+      {
+        id: "action btns",
+        Header: "",
+        Cell: ({ row }: CellType) => {
+          return <></>;
+          // return (
+          //   <Button
+          //     icon={<FaTrashAlt />}
+          //     color="danger"
+          //     inverted
+          //     onClick={
+          //       () =>
+          //        removeAnchorMutation.mutate({
+          //        documentId: row.original.document.id,
+          //        entityId: entityId,
+          //        })
+          //     }
+          //   />
+          // );
+        },
+      },
+    ],
+    [entities]
+  );
+
+  return (
+    <>
+      <Table
+        entityTitle={title}
+        columns={columns}
+        data={data}
+        perPage={perPage}
+      />
+      {openedDocument && (
+        <DocumentModalEdit
+          document={openedDocument}
+          onClose={() => {
+            setOpenedDocument(false);
+            setTempAnchor(false);
+          }}
+          anchor={tempAnchor ? { entityId: tempAnchor } : undefined}
+        />
+      )}
+    </>
+  );
+};
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTableStyles.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTableStyles.tsx
new file mode 100644
index 000000000..b077da088
--- /dev/null
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailUsedInTable/EntityDetailUsedInDocumentsTable/EntityDetailUsedInDocumentsTableStyles.tsx
@@ -0,0 +1,16 @@
+import styled from "styled-components";
+
+export const StyledAnchorText = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 0.3rem;
+  /* justify-content: center; */
+  font-size: ${({ theme }) => theme.fontSize["sm"]};
+`;
+
+export const StyledAbbreviatedLabel = styled.div`
+  overflow: hidden;
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 1;
+`;
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationText/EntityDetailValidationTextStyles.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationRule/EntityDetailValidationText/EntityDetailValidationTextStyles.tsx
deleted file mode 100644
index e69de29bb..000000000
diff --git a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationSection.tsx b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationSection.tsx
index 552de6790..8796fbc5b 100644
--- a/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationSection.tsx
+++ b/packages/client/src/pages/Main/containers/EntityDetailBox/EntityDetail/EntityDetailValidationSection/EntityDetailValidationSection.tsx
@@ -19,7 +19,7 @@ import {
   StyledDetailSectionHeader,
   StyledValidationList,
 } from "../EntityDetailStyles";
-import { EntityDetailValidationRule } from "./EntityDetailValidationRule/EntityDetailValidationRule";
+import { ValidationRule } from "components/advanced";
 
 const initValidation: ITerritoryValidation = {
   detail: "",
@@ -171,7 +171,7 @@ export const EntityDetailValidationSection: React.FC<
           {(validations as ITerritoryValidation[]).map((validation, key) => {
             return (
               <React.Fragment key={key}>
-                <EntityDetailValidationRule
+                <ValidationRule
                   key={key}
                   validation={validation}
                   entities={entities}
diff --git a/packages/client/src/pages/Main/containers/StatementsListBox/StatementListTextAnnotator/StatementListTextAnnotator.tsx b/packages/client/src/pages/Main/containers/StatementsListBox/StatementListTextAnnotator/StatementListTextAnnotator.tsx
index 1534a84c9..542ce90bc 100644
--- a/packages/client/src/pages/Main/containers/StatementsListBox/StatementListTextAnnotator/StatementListTextAnnotator.tsx
+++ b/packages/client/src/pages/Main/containers/StatementsListBox/StatementListTextAnnotator/StatementListTextAnnotator.tsx
@@ -4,7 +4,7 @@ import { EntityEnums, UserEnums } from "@shared/enums";
 import { IEntity, IResponseEntity, IResponseStatement } from "@shared/types";
 import { useQuery } from "@tanstack/react-query";
 import api from "api";
-import { Button, Input, Loader } from "components";
+import { Button, Input, Loader, DocumentTitle } from "components";
 import Dropdown, { EntitySuggester, EntityTag } from "components/advanced";
 import TextAnnotator from "components/advanced/Annotator/Annotator";
 import AnnotatorProvider from "components/advanced/Annotator/AnnotatorProvider";
@@ -17,10 +17,6 @@ import { ThemeContext } from "styled-components";
 import { COLLAPSED_TABLE_WIDTH } from "Theme/constants";
 import useResizeObserver from "use-resize-observer";
 import { StyledInfoText } from "../StatementListHeader/StatementListHeaderStyles";
-import {
-  StyledDocumentTag,
-  StyledDocumentTitle,
-} from "../StatementLitBoxStyles";
 import { entitiesDict } from "@shared/dictionaries/entity";
 import { useDebounce } from "hooks";
 
@@ -320,18 +316,7 @@ export const StatementListTextAnnotator: React.FC<
         {!selectedDocumentIsFetching && (
           <>
             {selectedDocument && (
-              <>
-                <StyledDocumentTag>
-                  <TiDocumentText
-                    style={{ marginRight: "0.2rem", flexShrink: "0" }}
-                  />
-                  <div style={{ display: "grid" }}>
-                    <StyledDocumentTitle>
-                      {selectedDocument?.title}
-                    </StyledDocumentTitle>
-                  </div>
-                </StyledDocumentTag>
-              </>
+              <DocumentTitle title={selectedDocument.title} />
             )}
           </>
         )}
@@ -427,7 +412,7 @@ export const StatementListTextAnnotator: React.FC<
           </StyledInfoText>
           <Input
             value={searchTerm}
-            onChangeFn={(newText) => {
+            onChangeFn={(newText: any) => {
               setSearchTerm(newText);
             }}
             changeOnType
diff --git a/packages/client/src/pages/Main/containers/StatementsListBox/StatementLitBoxStyles.tsx b/packages/client/src/pages/Main/containers/StatementsListBox/StatementLitBoxStyles.tsx
index 6cf77138c..856c3d082 100644
--- a/packages/client/src/pages/Main/containers/StatementsListBox/StatementLitBoxStyles.tsx
+++ b/packages/client/src/pages/Main/containers/StatementsListBox/StatementLitBoxStyles.tsx
@@ -50,22 +50,3 @@ export const StyledEmptyState = styled.div`
   align-items: center;
   text-align: center;
 `;
-
-export const StyledDocumentTag = styled.div`
-  display: inline-flex;
-  margin: 0 0.6rem;
-  background-color: ${({ theme }) => theme.color["blue"][400]};
-  padding: ${({ theme }) => theme.space[1] + " " + theme.space[3]};
-  border-radius: ${({ theme }) => theme.borderRadius["md"]};
-  color: white;
-  font-size: small;
-  align-items: center;
-`;
-
-export const StyledDocumentTitle = styled.p`
-  display: inline-block;
-  vertical-align: middle;
-  white-space: nowrap;
-  overflow: hidden !important;
-  text-overflow: ellipsis;
-`;
diff --git a/packages/client/src/pages/Users/containers/UserList/UserList.tsx b/packages/client/src/pages/Users/containers/UserList/UserList.tsx
index b23754874..90d22cb62 100644
--- a/packages/client/src/pages/Users/containers/UserList/UserList.tsx
+++ b/packages/client/src/pages/Users/containers/UserList/UserList.tsx
@@ -17,14 +17,11 @@ import {
   FaToggleOn,
   FaTrashAlt,
 } from "react-icons/fa";
-import {
-  RiUserSearchFill,
-  RiUserSettingsFill,
-  RiUserStarFill,
-} from "react-icons/ri";
 import { CellProps, Column, Row, useTable } from "react-table";
 import { toast } from "react-toastify";
+import { getUserIcon } from "utils/utils";
 import { UserListEmailInput } from "./UserListEmailInput/UserListEmailInput";
+import { UserListIcon } from "./UserListIcon/UserListIcon";
 import {
   StyledNotActiveText,
   StyledTHead,
@@ -44,6 +41,13 @@ import { UserListTableRow } from "./UserListTableRow/UserListTableRow";
 import { UserListUsernameInput } from "./UserListUsernameInput/UserListUsernameInput";
 import { UsersUtils } from "./UsersUtils";
 
+const rolePriority: Record<UserEnums.Role, number> = {
+  [UserEnums.Role.Owner]: 1,
+  [UserEnums.Role.Admin]: 2,
+  [UserEnums.Role.Editor]: 3,
+  [UserEnums.Role.Viewer]: 4,
+};
+
 type CellType = CellProps<IResponseUser>;
 
 interface UserList {}
@@ -67,11 +71,21 @@ export const UserList: React.FC<UserList> = React.memo(() => {
     enabled: api.isLoggedIn(),
   });
 
-  // const localUsers = useMemo(() => users || [], [users]);
   const [localUsers, setLocalUsers] = useState<IResponseUser[]>([]);
+
+  const userComparator = (a: IResponseUser, b: IResponseUser): number => {
+    // First, compare by role priority
+    if (rolePriority[a.role] !== rolePriority[b.role]) {
+      return rolePriority[a.role] - rolePriority[b.role];
+    }
+
+    // If roles are the same, compare by active status
+    return b.active ? 1 : -1;
+  };
+
   useEffect(() => {
     if (users) {
-      setLocalUsers(users);
+      setLocalUsers(users.sort(userComparator));
     }
   }, [users]);
 
@@ -151,19 +165,20 @@ export const UserList: React.FC<UserList> = React.memo(() => {
         Cell: ({ row }: CellType) => {
           const { name, email, role, active, verified } = row.original;
 
-          let icon = <RiUserSearchFill />;
-          if (role === UserEnums.Role.Admin) {
-            icon = <RiUserStarFill />;
-          }
-          if (role === UserEnums.Role.Editor) {
-            icon = <RiUserSettingsFill />;
-          }
-          if (!verified) {
-            icon = <FaEnvelopeOpenText size={16} />;
-          }
           return (
             <StyledUserNameColumn $active={active} $verified={verified}>
-              <StyledUserNameColumnIcon>{icon}</StyledUserNameColumnIcon>
+              <StyledUserNameColumnIcon>
+                <UserListIcon
+                  icon={
+                    !verified ? (
+                      <FaEnvelopeOpenText size={16} />
+                    ) : (
+                      getUserIcon(role)
+                    )
+                  }
+                  tooltipLabel={role}
+                />
+              </StyledUserNameColumnIcon>
 
               {!verified ? (
                 <StyledNotActiveText>
@@ -219,42 +234,61 @@ export const UserList: React.FC<UserList> = React.memo(() => {
           const { id, role } = row.original;
           return (
             <AttributeButtonGroup
-              disabled={id === localStorage.getItem("userid")}
-              options={[
-                {
-                  longValue: userRoleDict[0].label,
-                  shortValue: userRoleDict[0].label,
-                  selected: role === userRoleDict[0].value,
-                  onClick: () => {
-                    userMutation.mutate({
-                      id: id,
-                      role: userRoleDict[0].value,
-                    });
-                  },
-                },
-                {
-                  longValue: userRoleDict[1].label,
-                  shortValue: userRoleDict[1].label,
-                  selected: role === userRoleDict[1].value,
-                  onClick: () => {
-                    userMutation.mutate({
-                      id: id,
-                      role: userRoleDict[1].value,
-                    });
-                  },
-                },
-                {
-                  longValue: userRoleDict[2].label,
-                  shortValue: userRoleDict[2].label,
-                  selected: role === userRoleDict[2].value,
-                  onClick: () => {
-                    userMutation.mutate({
-                      id: id,
-                      role: userRoleDict[2].value,
-                    });
-                  },
-                },
-              ]}
+              disabled={
+                id === localStorage.getItem("userid") ||
+                role === UserEnums.Role.Owner
+              }
+              options={
+                role === UserEnums.Role.Owner
+                  ? [
+                      {
+                        longValue: userRoleDict[0].label,
+                        shortValue: userRoleDict[0].label,
+                        selected: role === userRoleDict[0].value,
+                        onClick: () => {
+                          userMutation.mutate({
+                            id: id,
+                            role: userRoleDict[0].value,
+                          });
+                        },
+                      },
+                    ]
+                  : [
+                      {
+                        longValue: userRoleDict[1].label,
+                        shortValue: userRoleDict[1].label,
+                        selected: role === userRoleDict[1].value,
+                        onClick: () => {
+                          userMutation.mutate({
+                            id: id,
+                            role: userRoleDict[1].value,
+                          });
+                        },
+                      },
+                      {
+                        longValue: userRoleDict[2].label,
+                        shortValue: userRoleDict[2].label,
+                        selected: role === userRoleDict[2].value,
+                        onClick: () => {
+                          userMutation.mutate({
+                            id: id,
+                            role: userRoleDict[2].value,
+                          });
+                        },
+                      },
+                      {
+                        longValue: userRoleDict[3].label,
+                        shortValue: userRoleDict[3].label,
+                        selected: role === userRoleDict[3].value,
+                        onClick: () => {
+                          userMutation.mutate({
+                            id: id,
+                            role: userRoleDict[3].value,
+                          });
+                        },
+                      },
+                    ]
+              }
             />
           );
         },
@@ -448,6 +482,7 @@ export const UserList: React.FC<UserList> = React.memo(() => {
             territoryRights: territoryActants,
             active,
             verified,
+            role,
           } = row.original;
 
           let activateTooltip = "activate user";
@@ -455,6 +490,8 @@ export const UserList: React.FC<UserList> = React.memo(() => {
             activateTooltip = "cannot activate unverified user";
           } else if (userId === localStorage.getItem("userid")) {
             activateTooltip = "cannot deactivate yourself";
+          } else if (role === UserEnums.Role.Owner) {
+            activateTooltip = "owner must be active";
           } else if (active) {
             activateTooltip = "deactivate user";
           }
@@ -471,7 +508,10 @@ export const UserList: React.FC<UserList> = React.memo(() => {
                 icon={<FaTrashAlt size={14} />}
                 color="danger"
                 tooltipLabel={deleteTooltip}
-                disabled={userId === localStorage.getItem("userid")}
+                disabled={
+                  userId === localStorage.getItem("userid") ||
+                  role === UserEnums.Role.Owner
+                }
                 onClick={() => {
                   setRemovingUserId(userId);
                 }}
@@ -490,7 +530,9 @@ export const UserList: React.FC<UserList> = React.memo(() => {
                   active ? <FaToggleOn size={14} /> : <FaToggleOff size={14} />
                 }
                 disabled={
-                  !verified || userId === localStorage.getItem("userid")
+                  !verified ||
+                  userId === localStorage.getItem("userid") ||
+                  role === UserEnums.Role.Owner
                 }
                 color={active ? "success" : "danger"}
                 tooltipLabel={activateTooltip}
diff --git a/packages/client/src/pages/Users/containers/UserList/UserListIcon/UserListIcon.tsx b/packages/client/src/pages/Users/containers/UserList/UserListIcon/UserListIcon.tsx
new file mode 100644
index 000000000..c6587a58d
--- /dev/null
+++ b/packages/client/src/pages/Users/containers/UserList/UserListIcon/UserListIcon.tsx
@@ -0,0 +1,43 @@
+import {
+  AutoPlacement,
+  BasePlacement,
+  VariationPlacement,
+} from "@popperjs/core";
+import { Tooltip } from "components";
+import React, { useState } from "react";
+
+interface UserListIcon {
+  icon: React.ReactNode;
+  tooltipLabel?: string;
+  tooltipPosition?: AutoPlacement | BasePlacement | VariationPlacement;
+}
+export const UserListIcon: React.FC<UserListIcon> = ({
+  icon,
+  tooltipLabel,
+  tooltipPosition,
+}) => {
+  const [referenceElement, setReferenceElement] =
+    useState<HTMLSpanElement | null>(null);
+  const [showTooltip, setShowTooltip] = useState(false);
+
+  return (
+    <>
+      <span
+        ref={setReferenceElement}
+        onMouseEnter={() => setShowTooltip(true)}
+        onMouseLeave={() => setShowTooltip(false)}
+      >
+        {icon}
+      </span>
+
+      {tooltipLabel && (
+        <Tooltip
+          label={tooltipLabel}
+          visible={showTooltip}
+          referenceElement={referenceElement}
+          position={tooltipPosition}
+        />
+      )}
+    </>
+  );
+};
diff --git a/packages/client/src/pages/Users/containers/UserList/UserListStyles.tsx b/packages/client/src/pages/Users/containers/UserList/UserListStyles.tsx
index b292d25cc..3600ff0da 100644
--- a/packages/client/src/pages/Users/containers/UserList/UserListStyles.tsx
+++ b/packages/client/src/pages/Users/containers/UserList/UserListStyles.tsx
@@ -33,14 +33,18 @@ export const StyledTh = styled.th`
 
 interface StyledTr {
   $isOdd?: boolean;
-  $isSelected?: boolean;
   opacity?: number;
+  $isOwner: boolean;
+  $isAdmin: boolean;
 }
 export const StyledTr = styled.tr<StyledTr>`
-  background-color: ${({ theme, $isSelected }) =>
-    $isSelected ? theme.color["invertedBg"]["info"] : theme.color["white"]};
-  color: ${({ theme, $isSelected }) =>
-    $isSelected ? theme.color["primary"] : theme.color["black"]};
+  background-color: ${({ theme, $isOwner, $isAdmin }) =>
+    $isOwner
+      ? theme.color["invertedBg"]["primary"]
+      : $isAdmin
+      ? theme.color["invertedBg"]["info"]
+      : theme.color["white"]};
+  color: ${({ theme, $isOwner }) => theme.color["black"]};
   opacity: ${({ opacity }) => (opacity ? opacity : 1)};
   padding: ${({ theme }) => theme.space[1]};
   border: 1px solid ${({ theme }) => theme.color["gray"][400]};
diff --git a/packages/client/src/pages/Users/containers/UserList/UserListTableRow/UserListTableRow.tsx b/packages/client/src/pages/Users/containers/UserList/UserListTableRow/UserListTableRow.tsx
index 13d0934b3..efbe8a69a 100644
--- a/packages/client/src/pages/Users/containers/UserList/UserListTableRow/UserListTableRow.tsx
+++ b/packages/client/src/pages/Users/containers/UserList/UserListTableRow/UserListTableRow.tsx
@@ -2,21 +2,24 @@ import { IResponseUser } from "@shared/types";
 import React from "react";
 import { Row } from "react-table";
 import { StyledTd, StyledTr } from "../UserListStyles";
+import { UserEnums } from "@shared/enums";
 
 interface UserListTableRow {
   row: Row<IResponseUser>;
   index: number;
-  isSelected?: boolean;
 }
 
 export const UserListTableRow: React.FC<UserListTableRow> = ({
   row,
   index,
-  isSelected = false,
 }) => {
   return (
     <React.Fragment key={index}>
-      <StyledTr $isOdd={Boolean(index % 2)} $isSelected={isSelected}>
+      <StyledTr
+        $isOwner={row.original.role === UserEnums.Role.Owner}
+        $isAdmin={row.original.role === UserEnums.Role.Admin}
+        $isOdd={Boolean(index % 2)}
+      >
         {row.cells.map((cell) => {
           return (
             <StyledTd {...cell.getCellProps()}>{cell.render("Cell")}</StyledTd>
diff --git a/packages/client/src/utils/utils.ts b/packages/client/src/utils/utils.tsx
similarity index 92%
rename from packages/client/src/utils/utils.ts
rename to packages/client/src/utils/utils.tsx
index 513caee70..f7b29a48c 100644
--- a/packages/client/src/utils/utils.ts
+++ b/packages/client/src/utils/utils.tsx
@@ -1,5 +1,7 @@
+import { FaUserGear, FaUserTie } from "react-icons/fa6";
+import { FaUserEdit, FaUserTag } from "react-icons/fa";
 import { classesAll } from "@shared/dictionaries/entity";
-import { EntityEnums, RelationEnums } from "@shared/enums";
+import { EntityEnums, RelationEnums, UserEnums } from "@shared/enums";
 import {
   EntityTooltip,
   IEntity,
@@ -10,6 +12,7 @@ import {
 } from "@shared/types";
 import { DropTargetMonitor, XYCoord } from "react-dnd";
 import { DragItem, EntityDragItem } from "types";
+import React from "react";
 
 // is used to render italic for S, could be handled other way when first label "" is obligatory
 export const isFirstLabelEmpty = (labels: string[]) =>
@@ -318,3 +321,18 @@ export const normalizeURL = (url: string) => {
   }
   return url;
 };
+
+export const getUserIcon = (
+  userRole: UserEnums.Role,
+  // size can be determined in parent component font-size instead
+  size?: number
+): React.ReactNode => {
+  if (userRole === UserEnums.Role.Owner) {
+    return <FaUserGear size={size} />;
+  } else if (userRole === UserEnums.Role.Admin) {
+    return <FaUserTie size={size} />;
+  } else if (userRole === UserEnums.Role.Editor) {
+    return <FaUserEdit size={size} />;
+  }
+  return <FaUserTag size={size} />;
+};
diff --git a/packages/database/datasets/all-parsed/users.json b/packages/database/datasets/all-parsed/users.json
index 403f1be60..4c8927c18 100644
--- a/packages/database/datasets/all-parsed/users.json
+++ b/packages/database/datasets/all-parsed/users.json
@@ -38,6 +38,27 @@
   },
   {
     "id": "2",
+    "name": "owner",
+    "email": "owner@owner.com",
+    "password": "owner",
+    "active": true,
+    "verified": true,
+    "options": {
+      "defaultTerritory": "",
+      "defaultLanguage": "",
+      "searchLanguages": []
+    },
+    "bookmarks": null,
+    "role": "owner",
+    "rights": [
+      {
+        "territory": "T0",
+        "mode": "admin"
+      }
+    ]
+  },
+  {
+    "id": "3",
     "name": "editor1",
     "email": "editor@inkvisitor.com",
     "password": "abc",
@@ -53,7 +74,7 @@
     "rights": []
   },
   {
-    "id": "3",
+    "id": "4",
     "name": "editor2",
     "email": "editor2@inkvisitor.com",
     "password": "def",
@@ -69,7 +90,7 @@
     "rights": []
   },
   {
-    "id": "4",
+    "id": "5",
     "name": "viewer1",
     "email": "viewer1@inkvisitor.com",
     "password": "viewer",
@@ -85,7 +106,7 @@
     "rights": []
   },
   {
-    "id": "5",
+    "id": "6",
     "name": "inactive",
     "email": "inactive@inkvisitor.com",
     "password": "inactive",
diff --git a/packages/database/datasets/default/acl_permissions.json b/packages/database/datasets/default/acl_permissions.json
index 9d11afa29..a7fb6d6b9 100644
--- a/packages/database/datasets/default/acl_permissions.json
+++ b/packages/database/datasets/default/acl_permissions.json
@@ -1,4 +1,11 @@
 [
+  {
+    "controller": "users",
+    "route": "owner",
+    "method": "GET",
+    "roles": ["*"],
+    "public": true
+  },
   {
     "controller": "acls",
     "route": "",
@@ -19,8 +26,7 @@
   },
   {
     "controller": "statements",
-    "route": ":statementId",
-    "method": "GET",
+    "route": ":statementId","method": "GET",
     "roles": ["*"]
   },
   {
@@ -250,5 +256,26 @@
     "route": "",
     "method": "DELETE",
     "roles": ["*"]
+  },
+  {
+    "controller": "settings",
+    "route": ":key",
+    "method": "GET",
+    "roles": ["*"],
+    "public": true
+  },
+  {
+    "controller": "settings",
+    "route": ":key",
+    "method": "PUT",
+    "roles": ["admin"],
+    "public": false
+  },
+  {
+    "controller": "settings",
+    "route": "group/:groupkey",
+    "method": "PUT",
+    "roles": ["admin"],
+    "public": false
   }
 ]
diff --git a/packages/database/datasets/default/settings.json b/packages/database/datasets/default/settings.json
new file mode 100644
index 000000000..80ef951b9
--- /dev/null
+++ b/packages/database/datasets/default/settings.json
@@ -0,0 +1,28 @@
+[
+  { "id": "validation_SValency", "value": true },
+  { "id": "validation_A1Valency", "value": true },
+  { "id": "validation_A2Valency", "value": true },
+  { "id": "validation_NoTerritory", "value": true },
+  { "id": "validation_NA", "value": true },
+  { "id": "validation_MA", "value": true },
+  { "id": "validation_WA", "value": true },
+  { "id": "validation_ANA", "value": true },
+  { "id": "validation_WAC", "value": true },
+  { "id": "validation_AVU", "value": true },
+  { "id": "validation_IELVL", "value": true },
+  { "id": "validation_SCLM", "value": true },
+  { "id": "validation_ISYNC", "value": true },
+  { "id": "validation_MVAL", "value": true },
+  { "id": "validation_AVAL", "value": true },
+  { "id": "validation_MAEE", "value": true },
+  { "id": "validation_PSM", "value": true },
+  { "id": "validation_LM", "value": true },
+  { "id": "validation_VETM", "value": true },
+  { "id": "validation_TVEP", "value": true },
+  { "id": "validation_TVEPT", "value": true },
+  { "id": "validation_TVEPV", "value": true },
+  { "id": "validation_TVEC", "value": true },
+  { "id": "validation_TVECE", "value": true },
+  { "id": "validation_TVER", "value": true },
+  { "id": "validation_TVERE", "value": true }
+]
diff --git a/packages/database/datasets/default/users.json b/packages/database/datasets/default/users.json
index 32bbd7125..cb313e82a 100644
--- a/packages/database/datasets/default/users.json
+++ b/packages/database/datasets/default/users.json
@@ -38,6 +38,27 @@
   },
   {
     "id": "2",
+    "name": "owner",
+    "email": "owner@owner.com",
+    "password": "owner",
+    "active": true,
+    "verified": true,
+    "options": {
+      "defaultTerritory": "",
+      "defaultLanguage": "",
+      "searchLanguages": []
+    },
+    "bookmarks": null,
+    "role": "owner",
+    "rights": [
+      {
+        "territory": "T0",
+        "mode": "admin"
+      }
+    ]
+  },
+  {
+    "id": "3",
     "name": "editor1",
     "email": "editor@inkvisitor.com",
     "password": "abc",
@@ -62,7 +83,7 @@
     ]
   },
   {
-    "id": "3",
+    "id": "4",
     "name": "editor2",
     "email": "editor2@inkvisitor.com",
     "password": "def",
@@ -83,7 +104,7 @@
     ]
   },
   {
-    "id": "4",
+    "id": "5",
     "name": "viewer1",
     "email": "viewer1@inkvisitor.com",
     "password": "viewer",
@@ -104,7 +125,7 @@
     ]
   },
   {
-    "id": "5",
+    "id": "6",
     "name": "inactive",
     "email": "inactive@inkvisitor.com",
     "password": "inactive",
diff --git a/packages/database/scripts/import.ts b/packages/database/scripts/import.ts
index 3e90a46c0..aa65aa505 100644
--- a/packages/database/scripts/import.ts
+++ b/packages/database/scripts/import.ts
@@ -17,8 +17,15 @@ import { SshHelper } from "./import/ssh";
 import colors from "colors/safe";
 import jobs from "./jobs/index";
 
+const defaultSettingsTable: TableSchema = {
+  tableName: "settings",
+  data: require("../datasets/default/settings.json"),
+  transform: function () {},
+};
+
 const datasets: Record<string, DbSchema> = {
   dissinet_documents: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: null,
@@ -51,6 +58,7 @@ const datasets: Record<string, DbSchema> = {
     },
   },
   empty: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: require("../datasets/default/users.json"),
@@ -102,8 +110,8 @@ const datasets: Record<string, DbSchema> = {
       transform: function () {},
     },
   },
-
   relationstest: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: require("../datasets/default/users.json"),
@@ -178,8 +186,8 @@ const datasets: Record<string, DbSchema> = {
       transform: function () {},
     },
   },
-
   allparsed: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: require("../datasets/all-parsed/users.json"),
@@ -252,6 +260,7 @@ const datasets: Record<string, DbSchema> = {
     },
   },
   initial_c: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: null,
@@ -287,6 +296,7 @@ const datasets: Record<string, DbSchema> = {
     },
   },
   initial_a: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: null,
@@ -322,6 +332,7 @@ const datasets: Record<string, DbSchema> = {
     },
   },
   acr: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: null,
@@ -358,6 +369,7 @@ const datasets: Record<string, DbSchema> = {
   },
 
   niort: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: require("../datasets/niort/users.json"),
@@ -399,6 +411,7 @@ const datasets: Record<string, DbSchema> = {
   },
 
   production: {
+    settings: defaultSettingsTable,
     users: {
       tableName: "users",
       data: require("../datasets/default/users.json"),
diff --git a/packages/database/scripts/import/common.ts b/packages/database/scripts/import/common.ts
index 5cce9dc86..f460d2f4b 100644
--- a/packages/database/scripts/import/common.ts
+++ b/packages/database/scripts/import/common.ts
@@ -2,7 +2,6 @@ import { RelationEnums } from "@shared/enums";
 import { Relation } from "@shared/types";
 import { RValue, RTable } from "rethinkdb-ts";
 
-
 export interface DbSchema {
   users: TableSchema;
   aclPermissions: TableSchema;
@@ -10,6 +9,7 @@ export interface DbSchema {
   audits: TableSchema;
   relations: TableSchema;
   documents: TableSchema;
+  settings: TableSchema;
 }
 
 export interface TableSchema {
@@ -27,7 +27,7 @@ export function parseArgs(): [datasetId: string, env: string] {
 }
 
 const [datasetId, env] = parseArgs();
-const envFile = `env/.env${env ? "." + env : ''}`;
+const envFile = `env/.env${env ? "." + env : ""}`;
 const envData = require("dotenv").config({ path: envFile }).parsed;
 
 if (!envData) {
diff --git a/packages/server/src/Server.ts b/packages/server/src/Server.ts
index 4b4f27735..ec4b72199 100644
--- a/packages/server/src/Server.ts
+++ b/packages/server/src/Server.ts
@@ -13,6 +13,7 @@ import StatementsRouter from "@modules/statements";
 import TreeRouter from "@modules/tree";
 import StatsRouter from "@modules/stats";
 import PythonApiRouter from "@modules/pythondata";
+import SettingsRouter from "@modules/settings";
 import DocumentsRouter from "@modules/documents";
 import Acl from "@middlewares/acl";
 import customizeRequest from "@middlewares/request";
@@ -24,11 +25,8 @@ import compression from "compression";
 import * as path from "path";
 import rateLimit from "express-rate-limit";
 import "@models/events/register";
-import { Request, RequestHandler, Response } from "express";
-import {
-  BadCredentialsError,
-  TooManyRequestsError,
-} from "@shared/types/errors";
+import { Request, Response } from "express";
+import { TooManyRequestsError } from "@shared/types/errors";
 
 const server = express();
 
@@ -124,6 +122,7 @@ server.use(
       /api\/v1\/users\/signin/,
       /api\/v1\/users\/activation/,
       /api\/v1\/users\/password/,
+      /api\/v1\/users\/owner/,
       /api\/v1\/pythondata/,
     ],
   })
@@ -151,6 +150,7 @@ routerV1.use("/tree", TreeRouter);
 routerV1.use("/stats", StatsRouter);
 routerV1.use("/documents", DocumentsRouter);
 routerV1.use("/pythondata", PythonApiRouter);
+routerV1.use("/settings", SettingsRouter);
 
 // unknown paths (after jwt check) should return 404
 server.all("*", catchAll);
diff --git a/packages/server/src/common/auth.ts b/packages/server/src/common/auth.ts
index 8384e1f29..ef219f960 100644
--- a/packages/server/src/common/auth.ts
+++ b/packages/server/src/common/auth.ts
@@ -47,10 +47,12 @@ export function checkPassword(
 const defaultJwtAlgo = "HS256";
 
 let secret = (process.env.SECRET as string) || "";
-if (process.argv.length > 3) {
-  secret += process.argv[3];
-} else if (process.env.BUILD_TIMESTAMP) {
-  secret += process.env.BUILD_TIMESTAMP;
+if (process.env.NODE_ENV !== "test") {
+  if (process.argv.length > 3) {
+    secret += process.argv[3];
+  } else if (process.env.BUILD_TIMESTAMP) {
+    secret += process.env.BUILD_TIMESTAMP;
+  }
 }
 
 if (secret) {
diff --git a/packages/server/src/middlewares/acl.ts b/packages/server/src/middlewares/acl.ts
index c7f235ecc..405ef7ee0 100644
--- a/packages/server/src/middlewares/acl.ts
+++ b/packages/server/src/middlewares/acl.ts
@@ -87,8 +87,10 @@ class Acl {
       return permissionDeniedErr;
     }
 
-    // allow admin for any route
-    if (req.getUserOrFail().role === UserEnums.Role.Admin) {
+    // allow admin/owner for any route
+    if (
+      req.getUserOrFail().hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])
+    ) {
       return null;
     }
 
diff --git a/packages/server/src/models/acl/acl_permission.ts b/packages/server/src/models/acl/acl_permission.ts
index 3f0911ed5..cc3fdf61b 100644
--- a/packages/server/src/models/acl/acl_permission.ts
+++ b/packages/server/src/models/acl/acl_permission.ts
@@ -1,7 +1,7 @@
 import { IResponsePermission } from "@shared/types";
 import { r as rethink, Connection, WriteResult, RDatum } from "rethinkdb-ts";
 import { IDbModel } from "@models/common";
-import { HttpMethods } from "@shared/enums";
+import { HttpMethods, UserEnums } from "@shared/enums";
 
 export default class AclPermission implements IDbModel, IResponsePermission {
   static table = "acl_permissions";
@@ -10,7 +10,7 @@ export default class AclPermission implements IDbModel, IResponsePermission {
   controller: string;
   route: string;
   method: HttpMethods;
-  roles: string[];
+  roles: UserEnums.Role[];
   public: boolean;
 
   constructor(data: Record<string, any>) {
@@ -63,11 +63,12 @@ export default class AclPermission implements IDbModel, IResponsePermission {
     return true;
   }
 
-  isRoleAllowed(group: string): boolean {
+  isRoleAllowed(group: UserEnums.Role): boolean {
     return (
       this.roles &&
       !!this.roles.length &&
-      (this.roles.indexOf("*") !== -1 || this.roles.indexOf(group) !== -1)
+      (this.roles.indexOf("*" as UserEnums.Role) !== -1 ||
+        this.roles.indexOf(group) !== -1)
     );
   }
 
diff --git a/packages/server/src/models/audit/audit.ts b/packages/server/src/models/audit/audit.ts
index 792af4b0f..21e03ce9b 100644
--- a/packages/server/src/models/audit/audit.ts
+++ b/packages/server/src/models/audit/audit.ts
@@ -85,7 +85,7 @@ export default class Audit implements IAudit, IDbModel {
     req: IRequest,
     entityId: string,
     updateData: object,
-    type: EventType,
+    type: EventType
   ): Promise<boolean> {
     const entry = new Audit({
       entityId,
@@ -189,7 +189,7 @@ export default class Audit implements IAudit, IDbModel {
       if (
         firstAudit &&
         firstAudit.date.toISOString().split("T")[0] ===
-        audit.date.toISOString().split("T")[0]
+          audit.date.toISOString().split("T")[0]
       ) {
         withValidDate.push(firstAudit);
       }
@@ -227,7 +227,7 @@ export default class Audit implements IAudit, IDbModel {
       if (
         firstAudit &&
         firstAudit.date.toISOString().split("T")[0] ===
-        audit.date.toISOString().split("T")[0]
+          audit.date.toISOString().split("T")[0]
       ) {
         withValidDate.push(firstAudit);
       }
@@ -235,4 +235,28 @@ export default class Audit implements IAudit, IDbModel {
 
     return withValidDate;
   }
+
+  /**
+   * returns first date-sorted entries for specific params
+   * @param db
+   * @param filter
+   * @returns
+   */
+  static async findMany(
+    db: Connection,
+    filter: { skip: number; take: number; from: Date }
+  ): Promise<Audit[]> {
+    const result = await rethink
+      .table(Audit.table)
+      .orderBy(rethink.asc("date"))
+      .filter(rethink.row("date").date().ge(filter.from))
+      .skip(filter.skip)
+      .limit(filter.take);
+
+    const audits = (await result.run(db)).map(
+      (data) => new Audit(data)
+    ) as Audit[];
+
+    return audits;
+  }
 }
diff --git a/packages/server/src/models/document/document.test.ts b/packages/server/src/models/document/document.test.ts
index cce117e47..490f9e9d8 100644
--- a/packages/server/src/models/document/document.test.ts
+++ b/packages/server/src/models/document/document.test.ts
@@ -83,3 +83,68 @@ describe("test Document.findByEntityId", function () {
     expect(shouldFindDocs).toHaveLength(0);
   });
 });
+
+describe("Document.removeAnchors", () => {
+  test("should remove only tags entities from document", () => {
+    const document = new Document({
+      content:
+        "some text <id123>other text</id123> additional <id342>blah </id342>ds>> >>?!<@>hello",
+      entityIds: ["id123", "id342"],
+    });
+    document.removeAnchors(["id123"]);
+    expect(document.content).toEqual(
+      "some text other text additional <id342>blah </id342>ds>> >>?!<@>hello"
+    );
+    expect(document.entityIds.find((e) => e === "id123")).toBeFalsy();
+    expect(document.entityIds.find((e) => e === "id342")).toBeTruthy();
+  });
+
+  test("should remove all anchors", () => {
+    const document = new Document({
+      content:
+        "some text <id123>other text</id123> <id123>other text</id123> additional <id342>blah </id342>ds>> >>?!<@>hello",
+      entityIds: ["id123", "id342"],
+    });
+    document.removeAnchors(["id123", "id342"]);
+    expect(document.content).toEqual(
+      "some text other text other text additional blah ds>> >>?!<@>hello"
+    );
+    expect(document.entityIds).toHaveLength(0);
+  });
+});
+
+describe("Document.buildAnchorsTree", () => {
+  const content = `header: /,/.
+    <tag1>
+        Hello, this is <tag2>some <tag3>deeply nested</tag3> text</tag2> 
+        within <tag4>multiple <tag5>levels</tag5> of tags</tag4>.
+    </tag1>
+    <tag6>Another root tag</tag6>
+    <tag7>
+        <tag8>More nested <tag9>content</tag9></tag8>
+    </tag7>
+
+    // footer //
+`;
+  const document = new Document({
+    content: content,
+  });
+
+  const tree = document.buildAnchorsTree();
+  it("should contain 3 root anchors", () => {
+    expect(tree).toHaveLength(3);
+  });
+
+  it("should have tag1 as first anchor", () => {
+    expect(tree[0].anchor).toEqual("tag1");
+  });
+
+  it("should have tag1 with 2 childs", () => {
+    expect(tree[0].children).toHaveLength(2);
+  });
+
+  it("should have tag1's first nested child tag2 and content valid", () => {
+    expect(tree[0].children[0].anchor).toEqual("tag2");
+    expect(tree[0].children[0].content).toEqual("some deeply nested text");
+  });
+});
diff --git a/packages/server/src/models/document/document.ts b/packages/server/src/models/document/document.ts
index 1932f8aa1..f1a8b86f2 100644
--- a/packages/server/src/models/document/document.ts
+++ b/packages/server/src/models/document/document.ts
@@ -1,10 +1,34 @@
 import { IDbModel } from "@models/common";
 import { r as rethink, Connection, WriteResult, RDatum } from "rethinkdb-ts";
-import { IDocument, IResponseDocument } from "@shared/types";
-import { UserEnums } from "@shared/enums";
+import { IDocument, IEntity } from "@shared/types";
+import { EntityEnums, UserEnums } from "@shared/enums";
 import { InternalServerError, ModelNotValidError } from "@shared/types/errors";
 import User from "@models/user/user";
-import { IDocumentMeta } from "@shared/types/document";
+
+export class TreeNode {
+  anchor: string; // The tag name (entity id)
+  children: TreeNode[] = []; // Nested children (other nodes)
+  content: string = ""; // Text content within the tag
+  class?: EntityEnums.Class; // will be populated in Document.assignClassesBasedOnEntities
+
+  static MAX_CONTENT_LENGTH = 20;
+
+  constructor(anchor: string, content: string = "") {
+    this.anchor = anchor;
+    this.content = content;
+  }
+
+  /**
+   * Returns sanitized content - shortened to MAX_CONTENT_LENGTH chars
+   * @returns
+   */
+  getShortContent(): string {
+    if (this.content.length > TreeNode.MAX_CONTENT_LENGTH) {
+      return this.content.slice(0, TreeNode.MAX_CONTENT_LENGTH) + "...";
+    }
+    return this.content;
+  }
+}
 
 export default class Document implements IDocument, IDbModel {
   static table = "documents";
@@ -32,7 +56,7 @@ export default class Document implements IDocument, IDbModel {
    * @returns
    */
   findEntities(): string[] {
-    const regex = /<([\w-]+)>/g;
+    const regex = /<([\w-\.]+)>/g;
     let match;
 
     const entities = [];
@@ -46,6 +70,128 @@ export default class Document implements IDocument, IDbModel {
     return uEntities;
   }
 
+  /**
+   * Finds content inside anchor-tags specified by entity id(tag)
+   * @param tag
+   * @returns
+   */
+  findAnchors(tag: string): string[] {
+    const regex = new RegExp(`<${tag}>(.*?)<\/${tag}>`, "g");
+
+    const result: string[] = [];
+
+    let match;
+    while ((match = regex.exec(this.content)) !== null) {
+      // match[1] contains the text inside the tag
+      result.push(match[1]);
+    }
+
+    return result;
+  }
+
+  buildAnchorsTree(): TreeNode[] {
+    const tagPattern = /<\/?([\w\-.]+)>/g; // Regex to match <tag> or </tag>
+    const rootNodes: TreeNode[] = [];
+    const nodeStack: TreeNode[] = [];
+
+    let lastIndex = 0;
+    let match: RegExpExecArray | null;
+
+    while ((match = tagPattern.exec(this.content)) !== null) {
+      const tag = match[1];
+      const isClosingTag = this.content[match.index + 1] === "/";
+
+      if (match.index > lastIndex) {
+        const text = this.content.slice(lastIndex, match.index);
+        if (text.length > 0 && nodeStack.length > 0) {
+          nodeStack[nodeStack.length - 1].content += text;
+        }
+      }
+
+      if (!isClosingTag) {
+        // Open tag: Create a new node for the tag
+        const newNode = new TreeNode(tag);
+        if (nodeStack.length > 0) {
+          nodeStack[nodeStack.length - 1].children.push(newNode);
+        } else {
+          // Root level node
+          rootNodes.push(newNode);
+        }
+        // Push the new node onto the stack (start processing its children)
+        nodeStack.push(newNode);
+      } else {
+        // Close tag: Pop the node off the stack
+        const closedNode = nodeStack.pop();
+
+        // If there's a parent node, merge the content of the closed node into its parent (remove tag, keep content)
+        if (closedNode && nodeStack.length > 0) {
+          nodeStack[nodeStack.length - 1].content += closedNode.content;
+        }
+      }
+
+      lastIndex = tagPattern.lastIndex;
+    }
+
+    // Handle any remaining text after the last tag
+    if (lastIndex < this.content.length) {
+      const remainingText = this.content.slice(lastIndex).trim();
+      if (remainingText.length > 0 && nodeStack.length > 0) {
+        nodeStack[nodeStack.length - 1].content += remainingText;
+      }
+    }
+
+    return rootNodes;
+  }
+
+  flattenTree(nodes: TreeNode[]): TreeNode[] {
+    const flatList: TreeNode[] = [];
+
+    function recurse(node: TreeNode) {
+      flatList.push(node); // Add current node to flat list
+      // Recurse through each child and flatten them
+      node.children.forEach((child) => recurse(child));
+    }
+
+    // Start recursion for each root node
+    nodes.forEach((node) => recurse(node));
+
+    return flatList;
+  }
+
+  collectAnchors(nodes: TreeNode[]): string[] {
+    const result: string[] = [];
+
+    nodes.forEach((node) => {
+      result.push(node.anchor); // Add the anchor of the current node
+
+      // Recursively collect anchors from the children
+      if (node.children.length > 0) {
+        result.push(...this.collectAnchors(node.children));
+      }
+    });
+
+    return result;
+  }
+
+  assignClassesBasedOnEntities(tree: TreeNode[], entities: IEntity[]): void {
+    const entityMap = new Map(
+      entities.map((entity) => [entity.id, entity.class])
+    ); // Create a map for faster lookup
+
+    function recurse(nodes: TreeNode[]) {
+      nodes.forEach((node) => {
+        // Check if the anchor matches any entity id
+        if (entityMap.has(node.anchor)) {
+          node.class = entityMap.get(node.anchor) || undefined; // Assign class if a match is found
+        }
+        // Recursively process children
+        recurse(node.children);
+      });
+    }
+
+    recurse(tree); // Start recursion
+  }
+
   /**
    * Stores the document in the db
    * @param db db connection
@@ -159,13 +305,22 @@ export default class Document implements IDocument, IDbModel {
     return true;
   }
 
+  removeAnchors(entityIds: string[]) {
+    for (const entityId of entityIds) {
+      const tagRegex = new RegExp(`<\\/?${entityId}(>|$)`, "g");
+      const updatedContent = this.content.replace(tagRegex, "");
+      this.content = updatedContent;
+      this.entityIds = this.entityIds.filter((id) => id !== entityId);
+    }
+  }
+
   /**
    * search for single document by ids
    * @param db Connection database connection
    * @param documentId string id
    * @returns Promise<Document> wanted document
    */
-  static async findDocumentById(
+  static async getDocumentById(
     db: Connection,
     documentId: string
   ): Promise<Document | null> {
@@ -201,16 +356,15 @@ export default class Document implements IDocument, IDbModel {
   static async findByEntityId(
     db: Connection,
     entityId: string
-  ): Promise<IDocumentMeta[]> {
+  ): Promise<IDocument[]> {
     const entries = await rethink
       .table(Document.table)
       .filter(function (row: RDatum) {
         return row("entityIds").contains(entityId);
       })
-      .without("content")
       .run(db);
 
-    return entries && entries.length ? (entries as IDocumentMeta[]) : [];
+    return entries && entries.length ? (entries as IDocument[]) : [];
   }
 
   /**
diff --git a/packages/server/src/models/entity/entity.ts b/packages/server/src/models/entity/entity.ts
index e24795f46..1581e52ad 100644
--- a/packages/server/src/models/entity/entity.ts
+++ b/packages/server/src/models/entity/entity.ts
@@ -1,20 +1,37 @@
-import { IDbModel, fillFlatObject, fillArray } from "@models/common";
-import { r as rethink, Connection, WriteResult, RDatum } from "rethinkdb-ts";
-import { IEntity, IProp, IReference } from "@shared/types";
-import { DbEnums, EntityEnums, UserEnums } from "@shared/enums";
+import { sanitizeText } from "@common/functions";
+import { IDbModel, fillArray, fillFlatObject } from "@models/common";
+import Prop from "@models/prop/prop";
+import User from "@models/user/user";
+import { findEntityById } from "@service/shorthands";
+import {
+  DbEnums,
+  EntityEnums,
+  UserEnums,
+  WarningTypeEnums,
+} from "@shared/enums";
+import {
+  IConcept,
+  IEntity,
+  IProp,
+  IReference,
+  ITerritory,
+  IWarning,
+} from "@shared/types";
+import { entityAllowedFields } from "@shared/types/entity";
 import {
   EntityDoesNotExist,
   InternalServerError,
-  InvalidDeleteError,
   ModelNotValidError,
 } from "@shared/types/errors";
-import User from "@models/user/user";
-import Prop from "@models/prop/prop";
-import { findEntityById } from "@service/shorthands";
+import {
+  EProtocolTieType,
+  ITerritoryValidation,
+} from "@shared/types/territory";
+import { Connection, RDatum, WriteResult, r as rethink } from "rethinkdb-ts";
 import { IRequest } from "../../custom_typings/request";
-import { sanitizeText } from "@common/functions";
 import Reference from "./reference";
-import { entityAllowedFields } from "@shared/types/entity";
+import { PropSpecKind } from "@shared/types/prop";
+import { IWarningPositionSection } from "@shared/types/warning";
 
 export default class Entity implements IEntity, IDbModel {
   static table = "entities";
@@ -188,7 +205,7 @@ export default class Entity implements IEntity, IDbModel {
    * @returns
    */
   getUserRoleMode(user: User): UserEnums.RoleMode {
-    if (user.role === UserEnums.Role.Admin) {
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return UserEnums.RoleMode.Admin;
     }
 
@@ -297,14 +314,15 @@ export default class Entity implements IEntity, IDbModel {
 
   static extractIdsFromProps(
     props: IProp[] = [],
+    accepted: PropSpecKind[] = [PropSpecKind.TYPE, PropSpecKind.VALUE],
     cb?: (prop: IProp) => void
   ): string[] {
     let out: string[] = [];
     for (const prop of props) {
-      if (prop.type) {
+      if (prop.type && accepted.includes(PropSpecKind.TYPE)) {
         out.push(prop.type.entityId);
       }
-      if (prop.value) {
+      if (prop.value && accepted.includes(PropSpecKind.VALUE)) {
         out.push(prop.value.entityId);
       }
 
@@ -312,7 +330,7 @@ export default class Entity implements IEntity, IDbModel {
         cb(prop);
       }
 
-      out = out.concat(Entity.extractIdsFromProps(prop.children, cb));
+      out = out.concat(Entity.extractIdsFromProps(prop.children, accepted, cb));
     }
 
     return out;
@@ -333,6 +351,193 @@ export default class Entity implements IEntity, IDbModel {
     return data;
   }
 
+  getTBasedWarnings(
+    territoryEs: ITerritory[],
+    classificationEs: IConcept[],
+    propValueEs: IEntity[]
+  ): IWarning[] {
+    const warnings: IWarning[] = [];
+
+    const validations: [string, ITerritoryValidation][] = [];
+    territoryEs.forEach((territory) =>
+      territory.data.validations
+        ?.filter((v) => v.active !== false)
+        .forEach((v) => validations.push([territory.id, v]))
+    );
+
+    const addNewValidationWarning = (
+      warningType: WarningTypeEnums,
+      teritoryId: string,
+      tValidation: ITerritoryValidation
+    ) => {
+      warnings.push({
+        type: warningType,
+        origin: this.id,
+        validation: tValidation,
+        position: {
+          section: IWarningPositionSection.Entity,
+          entityId: this.id,
+        },
+      });
+    };
+
+    validations.forEach(([tId, validation]) => {
+      const {
+        entityClasses,
+        classifications,
+        tieType,
+        propType,
+        allowedClasses,
+        allowedEntities,
+      } = validation;
+
+      // check if entity falls into the allowed classes
+      const entityCheck =
+        !entityClasses.length || entityClasses.includes(this.class);
+
+      // check if entity has the allowed classifications
+      const classificationCheck =
+        !classifications.length ||
+        classifications.some((c) =>
+          classificationEs.map((cla) => cla.id)?.includes(c)
+        );
+
+      if (entityCheck && classificationCheck) {
+        // CLASSIFICATION TIE
+        if (tieType === EProtocolTieType.Classification) {
+          if (!allowedEntities || !allowedEntities.length) {
+            // no condition set, so we need at least one classification
+            if (!classificationEs.length) {
+              addNewValidationWarning(WarningTypeEnums.TVEC, tId, validation);
+            }
+          } else {
+            // classifications of the entity
+            if (
+              !allowedEntities.some((classCondition) =>
+                classificationEs.map((cla) => cla.id)?.includes(classCondition)
+              )
+            ) {
+              addNewValidationWarning(WarningTypeEnums.TVECE, tId, validation);
+            }
+          }
+        }
+
+        // REFERENCE TIE
+        else if (tieType === EProtocolTieType.Reference) {
+          const eReferences = this.references.filter(
+            (r) => r.resource && r.value
+          );
+          // at least one reference (any) needs to be assigned to the E
+          if (!allowedEntities || !allowedEntities.length) {
+            if (eReferences.length === 0) {
+              addNewValidationWarning(WarningTypeEnums.TVER, tId, validation);
+            }
+          } else {
+            // at least one reference needs to be of the allowed entity
+            if (
+              !eReferences.some((r) => allowedEntities?.includes(r.resource))
+            ) {
+              addNewValidationWarning(WarningTypeEnums.TVERE, tId, validation);
+            }
+          }
+        }
+
+        // PROPERTY TIE
+        else if (tieType === EProtocolTieType.Property) {
+          const eProps = this.props.filter(
+            (p) => p.value.entityId && p.type.entityId
+          );
+
+          // at least one property needs to be assigned to the E
+          if (
+            !propType ||
+            (!propType.length &&
+              !allowedEntities?.length &&
+              !allowedClasses?.length)
+          ) {
+            if (eProps.length === 0) {
+              addNewValidationWarning(WarningTypeEnums.TVEP, tId, validation);
+            }
+
+            // type is defined but value is empty
+          } else if (
+            propType?.length &&
+            !allowedEntities?.length &&
+            !allowedClasses?.length
+          ) {
+            if (
+              eProps.length === 0 ||
+              !eProps.some((p) => propType?.includes(p.type.entityId))
+            ) {
+              addNewValidationWarning(WarningTypeEnums.TVEPT, tId, validation);
+            }
+          } else if (allowedEntities?.length || allowedClasses?.length) {
+            const validProps = eProps.filter((p) =>
+              propType?.length ? propType.includes(p.type.entityId) : true
+            );
+            if (!validProps?.length) {
+              addNewValidationWarning(WarningTypeEnums.TVEPV, tId, validation);
+            } else if (allowedClasses?.length) {
+              // class is required
+
+              // no valid props
+              if (validProps.length === 0) {
+                addNewValidationWarning(
+                  WarningTypeEnums.TVEPV,
+                  tId,
+                  validation
+                );
+              } else {
+                let passed = true;
+                for (const pi in eProps) {
+                  const p = eProps[pi];
+                  const propValueEntity = propValueEs.find(
+                    (e) => e.id === p.value.entityId
+                  );
+                  if (
+                    propValueEntity &&
+                    propType?.includes(p.type.entityId) &&
+                    !allowedClasses?.includes(propValueEntity.class)
+                  ) {
+                    passed = false;
+                  }
+                }
+                if (!passed) {
+                  addNewValidationWarning(
+                    WarningTypeEnums.TVEPV,
+                    tId,
+                    validation
+                  );
+                }
+              }
+            } else if (allowedEntities?.length) {
+              // entity is required
+              if (validProps.length === 0) {
+                addNewValidationWarning(
+                  WarningTypeEnums.TVEPV,
+                  tId,
+                  validation
+                );
+              } else if (
+                !validProps.some((p) =>
+                  allowedEntities.includes(p.value.entityId)
+                )
+              ) {
+                addNewValidationWarning(
+                  WarningTypeEnums.TVEPV,
+                  tId,
+                  validation
+                );
+              }
+            }
+          }
+        }
+      }
+    });
+
+    return warnings;
+  }
+
   async getEntities(db: Connection): Promise<IEntity[]> {
     return Entity.findEntitiesByIds(db, this.getEntitiesIds());
   }
diff --git a/packages/server/src/models/entity/response.test.ts b/packages/server/src/models/entity/response.test.ts
index 697ba79ec..dae77c142 100644
--- a/packages/server/src/models/entity/response.test.ts
+++ b/packages/server/src/models/entity/response.test.ts
@@ -11,9 +11,17 @@ import { EntityEnums } from "@shared/enums";
 import Prop, { PropSpec } from "@models/prop/prop";
 import Entity from "./entity";
 import { prepareStatement } from "@models/statement/statement.test";
-import { IResponseUsedInStatementClassification, IResponseUsedInStatementIdentification } from "@shared/types/response-detail";
+import {
+  IResponseUsedInDocument,
+  IResponseUsedInStatementClassification,
+  IResponseUsedInStatementIdentification,
+} from "@shared/types/response-detail";
 import { IStatement } from "@shared/types";
 import { prepareEntity } from "./entity.test";
+import { Db } from "@service/rethink";
+import Document from "@models/document/document";
+import Resource from "@models/resource/resource";
+import Territory from "@models/territory/territory";
 
 describe("models/entity/response", function () {
   describe("test ResponseEntityDetail.walkEntityProps", function () {
@@ -24,50 +32,63 @@ describe("models/entity/response", function () {
     describe("linked entry via prop.type & prop.children.value", () => {
       const response = new ResponseEntityDetail(firstEntity);
       const [, linkedEntity] = prepareEntity();
-      linkedEntity.props[0].type.entityId = firstEntity.id
-      linkedEntity.props[0].value.entityId = secondEntity.id
-      linkedEntity.props[0].children[0].type.entityId = secondEntity.id
-      linkedEntity.props[0].children[0].value.entityId = firstEntity.id
+      linkedEntity.props[0].type.entityId = firstEntity.id;
+      linkedEntity.props[0].value.entityId = secondEntity.id;
+      linkedEntity.props[0].children[0].type.entityId = secondEntity.id;
+      linkedEntity.props[0].children[0].value.entityId = firstEntity.id;
 
       response.walkEntityProps(origin, linkedEntity.props);
 
       it("should add to usedInMetaProps from prop.type", () => {
         const foundInType = response.usedInMetaProps.find(
-          (u) => u.originId === origin && u.typeId === firstEntity.id && u.valueId === secondEntity.id
+          (u) =>
+            u.originId === origin &&
+            u.typeId === firstEntity.id &&
+            u.valueId === secondEntity.id
         );
         expect(!!foundInType).toBeTruthy();
       });
 
       it("should have both props && props.children items in usedInMetaProps", () => {
-        expect(response.usedInMetaProps.length).toEqual(2)
+        expect(response.usedInMetaProps.length).toEqual(2);
       });
 
       it("should add to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds)).toEqual([firstEntity.id, secondEntity.id, origin]);
+        expect(Object.keys(response.linkedEntitiesIds)).toEqual([
+          firstEntity.id,
+          secondEntity.id,
+          origin,
+        ]);
       });
     });
 
     describe("linked entry via prop.children.type & prop.children.value", () => {
       const response = new ResponseEntityDetail(firstEntity);
       const [, linkedEntity] = prepareEntity();
-      linkedEntity.props[0].children[0].type.entityId = firstEntity.id
-      linkedEntity.props[0].children[0].value.entityId = firstEntity.id
+      linkedEntity.props[0].children[0].type.entityId = firstEntity.id;
+      linkedEntity.props[0].children[0].value.entityId = firstEntity.id;
 
       response.walkEntityProps(origin, linkedEntity.props);
 
       it("should add to usedInMetaProps from prop.type", () => {
         const foundInType = response.usedInMetaProps.find(
-          (u) => u.originId === origin && u.typeId === firstEntity.id && u.valueId === firstEntity.id
+          (u) =>
+            u.originId === origin &&
+            u.typeId === firstEntity.id &&
+            u.valueId === firstEntity.id
         );
         expect(!!foundInType).toBeTruthy();
       });
 
       it("only one item should be in usedInMetaProps", () => {
-        expect(response.usedInMetaProps.length).toEqual(1)
+        expect(response.usedInMetaProps.length).toEqual(1);
       });
 
       it("should add to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds)).toEqual([firstEntity.id, origin]);
+        expect(Object.keys(response.linkedEntitiesIds)).toEqual([
+          firstEntity.id,
+          origin,
+        ]);
       });
     });
   });
@@ -92,7 +113,9 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(i => i === st.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((i) => i === st.id)
+        ).toBeTruthy();
       });
     });
 
@@ -113,7 +136,9 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(i => i === st.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((i) => i === st.id)
+        ).toBeTruthy();
       });
     });
 
@@ -127,13 +152,16 @@ describe("models/entity/response", function () {
       it("should add entry to usedInStatements under Tag position", () => {
         const foundEntry = response.usedInStatements.find(
           (u) =>
-            u.statement.id === st.id && u.position === EntityEnums.UsedInPosition.Tag
+            u.statement.id === st.id &&
+            u.position === EntityEnums.UsedInPosition.Tag
         );
         expect(!!foundEntry).toBeTruthy();
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(i => i === st.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((i) => i === st.id)
+        ).toBeTruthy();
       });
     });
   });
@@ -156,7 +184,9 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(i => i === st.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((i) => i === st.id)
+        ).toBeTruthy();
       });
     });
 
@@ -175,7 +205,9 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(i => i === st.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((i) => i === st.id)
+        ).toBeTruthy();
       });
     });
 
@@ -194,7 +226,12 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds)).toEqual([entity.id, st.id, st.data.actions[0].actionId, st.data.actions[0].props[0].children[0].value.entityId])
+        expect(Object.keys(response.linkedEntitiesIds)).toEqual([
+          entity.id,
+          st.id,
+          st.data.actions[0].actionId,
+          st.data.actions[0].props[0].children[0].value.entityId,
+        ]);
       });
     });
 
@@ -214,7 +251,12 @@ describe("models/entity/response", function () {
       });
 
       it("should add entry to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds)).toEqual([entity.id, st.id, st.data.actions[0].actionId, st.data.actions[0].props[0].children[0].children[0].value.entityId])
+        expect(Object.keys(response.linkedEntitiesIds)).toEqual([
+          entity.id,
+          st.id,
+          st.data.actions[0].actionId,
+          st.data.actions[0].props[0].children[0].children[0].value.entityId,
+        ]);
       });
     });
 
@@ -223,7 +265,8 @@ describe("models/entity/response", function () {
       const [, st2] = prepareStatement();
 
       const response = new ResponseEntityDetail(entity);
-      st1.data.actions[0].props[0].children[0].children[0].type.entityId = entity.id;
+      st1.data.actions[0].props[0].children[0].children[0].type.entityId =
+        entity.id;
       st2.data.actions[0].props[0].value.entityId = entity.id;
 
       response.walkStatementsDataProps([st1, st2]);
@@ -243,8 +286,12 @@ describe("models/entity/response", function () {
       });
 
       it("should add both entries to linkedEntitiesIds map", () => {
-        expect(Object.keys(response.linkedEntitiesIds).find(k => k === st1.id)).toBeTruthy();
-        expect(Object.keys(response.linkedEntitiesIds).find(k => k === st2.id)).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((k) => k === st1.id)
+        ).toBeTruthy();
+        expect(
+          Object.keys(response.linkedEntitiesIds).find((k) => k === st2.id)
+        ).toBeTruthy();
       });
     });
   });
@@ -255,7 +302,7 @@ describe("models/entity/response", function () {
 
       beforeAll(async () => {
         await responseEmpty.populateInStatementsRelations([]);
-      })
+      });
 
       it("should yield empty relations", function () {
         expect(responseEmpty.usedInStatementIdentifications.length).toBe(0);
@@ -265,15 +312,15 @@ describe("models/entity/response", function () {
     });
 
     describe("with usedInStatements", function () {
-      const id = Math.random().toString()
+      const id = Math.random().toString();
       const correctIdentification = new StatementIdentification({
         certainty: EntityEnums.Certainty.Dubious,
         entityId: id,
-      })
+      });
       const correctClassification = new StatementClassification({
         certainty: EntityEnums.Certainty.Possible,
         entityId: id,
-      })
+      });
       const statementId = `${id}-statement`;
 
       const responseEmpty = new ResponseEntityDetail(new Entity({ id }));
@@ -288,33 +335,39 @@ describe("models/entity/response", function () {
           position: EntityEnums.UsedInPosition.Actant,
           statement: new Statement({
             data: new StatementData({
-              actants: [new StatementActant({
-                entityId: id,
-              })]
-            })
-          })
+              actants: [
+                new StatementActant({
+                  entityId: id,
+                }),
+              ],
+            }),
+          }),
         },
         {
           position: EntityEnums.UsedInPosition.Actant,
           statement: new Statement({
             id: statementId,
             data: new StatementData({
-              actants: [new StatementActant({
-                entityId: id,
-                classifications: [correctClassification],
-                identifications: [correctIdentification],
-              })]
-            })
-          })
-        }
-      ]
+              actants: [
+                new StatementActant({
+                  entityId: id,
+                  classifications: [correctClassification],
+                  identifications: [correctIdentification],
+                }),
+              ],
+            }),
+          }),
+        },
+      ];
 
       beforeAll(async () => {
         await responseEmpty.populateInStatementsRelations([]);
-      })
+      });
 
       it("should have 2 idems in linkedEntitiesIds map", function () {
-        expect(Object.keys(responseEmpty.linkedEntitiesIds)).toEqual([statementId]);
+        expect(Object.keys(responseEmpty.linkedEntitiesIds)).toEqual([
+          statementId,
+        ]);
       });
 
       it("should have expected classification & identification", function () {
@@ -323,32 +376,36 @@ describe("models/entity/response", function () {
           data: correctIdentification,
           relationEntityId: id,
           statementId: statementId,
-        }
+        };
         expect(responseEmpty.usedInStatementIdentifications.length).toBe(1);
-        expect(responseEmpty.usedInStatementIdentifications[0]).toEqual(wantedIdentification);
+        expect(responseEmpty.usedInStatementIdentifications[0]).toEqual(
+          wantedIdentification
+        );
 
         const wantedClassification: IResponseUsedInStatementClassification = {
           actantEntityId: id,
           data: correctClassification,
           relationEntityId: id,
           statementId: statementId,
-        }
+        };
 
         expect(responseEmpty.usedInStatementClassifications.length).toBe(1);
-        expect(responseEmpty.usedInStatementClassifications[0]).toEqual(wantedClassification);
+        expect(responseEmpty.usedInStatementClassifications[0]).toEqual(
+          wantedClassification
+        );
       });
     });
 
     describe("with statements", function () {
-      const id = Math.random().toString()
+      const id = Math.random().toString();
       const correctIdentification = new StatementIdentification({
         certainty: EntityEnums.Certainty.Dubious,
         entityId: id,
-      })
+      });
       const correctClassification = new StatementClassification({
         certainty: EntityEnums.Certainty.Possible,
         entityId: id,
-      })
+      });
       const statementId = `${id}-statement`;
 
       const responseEmpty = new ResponseEntityDetail(new Entity({ id }));
@@ -359,10 +416,12 @@ describe("models/entity/response", function () {
           data: new StatementData({
             actants: [
               new StatementActant({
-                identifications: [{ ...correctIdentification, entityId: "invalid" }]
-              })
-            ]
-          })
+                identifications: [
+                  { ...correctIdentification, entityId: "invalid" },
+                ],
+              }),
+            ],
+          }),
         }),
         // valid identifications & classifications
         new Statement({
@@ -373,18 +432,20 @@ describe("models/entity/response", function () {
                 entityId: "1", // different from entity id
                 identifications: [correctIdentification],
                 classifications: [correctClassification],
-              })
-            ]
-          })
-        })
+              }),
+            ],
+          }),
+        }),
       ];
 
       beforeAll(async () => {
         await responseEmpty.populateInStatementsRelations(statements);
-      })
+      });
 
       it("should have filled linkedEntitiesIds map", function () {
-        expect(Object.keys(responseEmpty.linkedEntitiesIds)).toEqual([statementId]);
+        expect(Object.keys(responseEmpty.linkedEntitiesIds)).toEqual([
+          statementId,
+        ]);
       });
 
       it("should have expected classification & identification", function () {
@@ -393,19 +454,128 @@ describe("models/entity/response", function () {
           data: correctIdentification,
           relationEntityId: id,
           statementId: statementId,
-        }
+        };
         expect(responseEmpty.usedInStatementIdentifications.length).toBe(1);
-        expect(responseEmpty.usedInStatementIdentifications[0]).toEqual(wantedIdentification);
+        expect(responseEmpty.usedInStatementIdentifications[0]).toEqual(
+          wantedIdentification
+        );
 
         const wantedClassification: IResponseUsedInStatementClassification = {
           actantEntityId: "1",
           data: correctClassification,
           relationEntityId: id,
           statementId: statementId,
-        }
+        };
         expect(responseEmpty.usedInStatementClassifications.length).toBe(1);
-        expect(responseEmpty.usedInStatementClassifications[0]).toEqual(wantedClassification);
+        expect(responseEmpty.usedInStatementClassifications[0]).toEqual(
+          wantedClassification
+        );
       });
     });
-  })
-})
+  });
+
+  describe("ResponseEntityDetail.findUsedInDocuments", function () {
+    let db: Db;
+    const territory1 = new Territory({
+      id: Math.random().toString(),
+      data: { parent: { territoryId: "T0", order: 0 } },
+    });
+    const territory2 = new Territory({
+      id: Math.random().toString(),
+      data: { parent: { territoryId: "T0", order: 1 } },
+    });
+    const entityWithoutDoc = new Entity({ id: Math.random().toString() });
+    const entityWithDoc = new Entity({ id: Math.random().toString() });
+    const doc1 = new Document({
+      id: Math.random().toString(),
+      content: `text<${entityWithDoc.id}>some anchor</${entityWithDoc.id}>not anchor here<${entityWithDoc.id}>some anchor 2</${entityWithDoc.id}>end`,
+    });
+    const doc2 = new Document({
+      id: Math.random().toString(),
+      content: `<${territory1.id}>text <${territory2.id}><${entityWithDoc.id}>anchor</${entityWithDoc.id}></${territory2.id}></${territory1.id}>`,
+    });
+    const resource1 = new Resource({
+      id: Math.random().toString(),
+      data: {
+        url: "",
+        partValueBaseURL: "",
+        partValueLabel: "",
+        documentId: doc1.id,
+      },
+    });
+    const resource2 = new Resource({
+      id: Math.random().toString(),
+      data: {
+        url: "",
+        partValueBaseURL: "",
+        partValueLabel: "",
+        documentId: doc2.id,
+      },
+    });
+    let usedInDocs: IResponseUsedInDocument[];
+
+    beforeAll(async () => {
+      db = new Db();
+      await db.initDb();
+      await territory1.save(db.connection);
+      await territory2.save(db.connection);
+      await doc1.save(db.connection);
+      await doc2.save(db.connection);
+      await entityWithDoc.save(db.connection);
+      await resource1.save(db.connection);
+      await resource2.save(db.connection);
+
+      const response = new ResponseEntityDetail(entityWithDoc);
+      usedInDocs = await response.findUsedInDocuments(db.connection);
+    });
+
+    afterAll(async () => {
+      await db.close();
+    });
+
+    it("should return empty array if no document exists", async () => {
+      const response = new ResponseEntityDetail(entityWithoutDoc);
+      const usedInDocs = await response.findUsedInDocuments(db.connection);
+
+      expect(usedInDocs).toHaveLength(0);
+    });
+
+    it("should return array with 3 instances", () => {
+      expect(usedInDocs).toHaveLength(3);
+    });
+
+    it("should have both anchors from first document", () => {
+      const doc1Results = usedInDocs.filter((d) => d.document.id === doc1.id);
+      expect(doc1Results).toHaveLength(2);
+      expect(doc1Results[0].anchorText === "some anchor").toBeTruthy();
+      expect(doc1Results[1].anchorText === "some anchor 2").toBeTruthy();
+    });
+
+    it("should have one anchor from second document", () => {
+      const doc2Results = usedInDocs.filter((d) => d.document.id === doc2.id);
+      expect(doc2Results).toHaveLength(1);
+      expect(doc2Results[0].anchorText === "anchor").toBeTruthy();
+    });
+
+    it("should find both resource ids", () => {
+      expect(
+        usedInDocs.find((d) => d.resourceId === resource1.id)
+      ).toBeTruthy();
+      expect(
+        usedInDocs.find((d) => d.resourceId === resource2.id)
+      ).toBeTruthy();
+    });
+
+    it("test parent territory in resource 1 occurence", () => {
+      expect(
+        usedInDocs.find((d) => d.resourceId === resource1.id)?.parentTerritoryId
+      ).toBeFalsy();
+    });
+
+    it("test parent territory in resource2 occurence", () => {
+      expect(
+        usedInDocs.find((d) => d.resourceId === resource2.id)?.parentTerritoryId
+      ).toEqual(territory2.id);
+    });
+  });
+});
diff --git a/packages/server/src/models/entity/response.ts b/packages/server/src/models/entity/response.ts
index ccd1ead30..94cd964e9 100644
--- a/packages/server/src/models/entity/response.ts
+++ b/packages/server/src/models/entity/response.ts
@@ -2,20 +2,19 @@ import { EntityEnums, RelationEnums, UserEnums } from "@shared/enums";
 import {
   IEntity,
   IProp,
-  Relation as RelationTypes,
   IResponseDetail,
   IResponseEntity,
   IResponseUsedInMetaProp,
   IResponseUsedInStatement,
   IStatement,
   IWarning,
-  IResponseDocument,
 } from "@shared/types";
 import Entity from "./entity";
 import Statement from "@models/statement/statement";
 import { nonenumerable } from "@common/decorators";
 import { Connection } from "rethinkdb-ts";
 import {
+  IResponseUsedInDocument,
   IResponseUsedInStatementClassification,
   IResponseUsedInStatementIdentification,
   IResponseUsedInStatementProps,
@@ -27,8 +26,9 @@ import {
 } from "@shared/types/statement";
 import { UsedRelations } from "@models/relation/relations";
 import EntityWarnings from "./warnings";
-import Document from "@models/document/document";
-import { IDocumentMeta } from "@shared/types/document";
+import Document, { TreeNode } from "@models/document/document";
+import Resource from "@models/resource/resource";
+import treeCache from "@service/treeCache";
 
 export class ResponseEntity extends Entity implements IResponseEntity {
   // map of entity ids that should be populated in subsequent methods and used in fetching
@@ -118,7 +118,7 @@ export class ResponseEntityDetail
   usedInStatementProps: IResponseUsedInStatementProps[];
   usedInMetaProps: IResponseUsedInMetaProp[];
   usedAsTemplate?: string[] | undefined;
-  usedInDocuments: IDocumentMeta[];
+  usedInDocuments: IResponseUsedInDocument[];
   usedInStatementIdentifications: IResponseUsedInStatementIdentification[];
   usedInStatementClassifications: IResponseUsedInStatementClassification[];
 
@@ -191,17 +191,88 @@ export class ResponseEntityDetail
       this.addLinkedEntities(this.relations.getEntityIdsFromType(type));
     }
 
+    // get warnings - bound to entity & from root territory
+    const entityWarnings = new EntityWarnings(this.id, this.class);
+    this.warnings = [
+      ...(await entityWarnings.getWarnings(req.db.connection)),
+      ...(await entityWarnings.getTBasedWarnings(
+        req.db.connection,
+        this,
+        treeCache.tree.getRootTerritory()
+      )),
+    ];
+
+    // get all documents data in IResponseUsedInDocument format
+    this.usedInDocuments = await this.findUsedInDocuments(conn);
+    this.usedInDocuments.forEach(ud => {
+      this.addLinkedEntities(ud.parentTerritoryId);
+      this.addLinkedEntities(ud.resourceId);
+    });
+
+    // fill all collected entities
     this.entities = await this.populateEntitiesMap(conn);
 
+    // apply casts from templates - must be done after populateEntitiesMap
     await this.processTemplateData(conn);
+  }
 
-    this.warnings = await new EntityWarnings(this.id, this.class).getWarnings(
-      req.db.connection
+  /**
+   * returns data for usedInDocuments(IResponseUsedInDocument[]) field
+   * @param conn
+   * @returns
+   */
+  async findUsedInDocuments(
+    conn: Connection
+  ): Promise<IResponseUsedInDocument[]> {
+    const out: IResponseUsedInDocument[] = [];
+    await Promise.all(
+      (
+        await Document.findByEntityId(conn, this.id)
+      ).map(async (docData) => {
+        // construct document and tree node filled with entities data
+        const doc = new Document({
+          content: docData.content,
+        });
+        const anchors = doc.buildAnchorsTree();
+        const anchoredEntities = await Entity.findEntitiesByIds(
+          conn,
+          doc.collectAnchors(anchors)
+        );
+        doc.assignClassesBasedOnEntities(anchors, anchoredEntities);
+
+        const resource = await Resource.findByDocumentId(conn, docData.id);
+
+        // traverse the tree, search for anchor that === this.id
+        const traverse = (nodes: TreeNode[], parentT?: string) => {
+          for (const node of nodes) {
+            if (node.anchor === this.id) {
+              out.push({
+                document: {
+                  id: docData.id,
+                  title: docData.title,
+                  entityIds: docData.entityIds,
+                  createdAt: docData.createdAt,
+                  updatedAt: docData.updatedAt,
+                },
+                anchorText: node.getShortContent(),
+                resourceId: resource?.id || "",
+                parentTerritoryId: parentT || "",
+              });
+            }
+
+            traverse(
+              node.children,
+              node.class === EntityEnums.Class.Territory ? node.anchor : parentT
+            );
+          }
+        };
+
+        traverse(anchors);
+      })
     );
 
-    this.usedInDocuments = await Document.findByEntityId(conn, this.id);
+    return out;
   }
-
   /**
    * Loads entries for usedInStatementIdentifications and usedInStatementClassifications fields
    * Needs to be called after walkStatementsDataEntities, since it uses also populated
diff --git a/packages/server/src/models/entity/warnings.ts b/packages/server/src/models/entity/warnings.ts
index bdecc9d62..1f219427f 100644
--- a/packages/server/src/models/entity/warnings.ts
+++ b/packages/server/src/models/entity/warnings.ts
@@ -1,12 +1,21 @@
+import Classification from "@models/relation/classification";
 import Relation from "@models/relation/relation";
 import Superclass from "@models/relation/superclass";
-import { findEntityById } from "@service/shorthands";
+import { findEntityById, getEntitiesByIds } from "@service/shorthands";
 import { EntityEnums, RelationEnums, WarningTypeEnums } from "@shared/enums";
-import { IAction, IConcept, IWarning } from "@shared/types";
+import {
+  IAction,
+  IConcept,
+  IEntity,
+  ITerritory,
+  IWarning,
+} from "@shared/types";
 import { IActionValency } from "@shared/types/action";
 import { InternalServerError } from "@shared/types/errors";
+import { PropSpecKind } from "@shared/types/prop";
 import { IWarningPositionSection } from "@shared/types/warning";
 import { Connection } from "rethinkdb-ts";
+import Entity from "./entity";
 
 export default class EntityWarnings {
   entityId: string;
@@ -89,6 +98,34 @@ export default class EntityWarnings {
     return warnings;
   }
 
+  async getTBasedWarnings(
+    conn: Connection,
+    entity: Entity,
+    rootTerritory: ITerritory
+  ): Promise<IWarning[]> {
+    const classificationRels =
+      await Classification.getClassificationForwardConnections(
+        conn,
+        entity.id,
+        entity.class,
+        1,
+        0
+      );
+    const classificationEs: IConcept[] = await getEntitiesByIds<IConcept>(
+      conn,
+      classificationRels.map((c) => c.entityIds[1])
+    );
+    const propValueEs = await getEntitiesByIds<IEntity>(
+      conn,
+      Entity.extractIdsFromProps(entity.props, [PropSpecKind.VALUE])
+    );
+    return entity.getTBasedWarnings(
+      [rootTerritory],
+      classificationEs,
+      propValueEs
+    );
+  }
+
   /**
    * Tests if there is SCLM warning and returns it
    * SCLM warning should pop when there is no superclass for this entity
diff --git a/packages/server/src/models/resource/resource.ts b/packages/server/src/models/resource/resource.ts
index 37d976436..1804daa7d 100644
--- a/packages/server/src/models/resource/resource.ts
+++ b/packages/server/src/models/resource/resource.ts
@@ -1,7 +1,8 @@
-import { fillFlatObject, UnknownObject, IModel } from "@models/common";
+import { fillFlatObject, IModel } from "@models/common";
 import { EntityEnums } from "@shared/enums";
 import { IResource, IResourceData } from "@shared/types/resource";
 import Entity from "@models/entity/entity";
+import { r as rethink, Connection } from "rethinkdb-ts";
 
 class ResourceData implements IResourceData, IModel {
   url = "";
@@ -37,6 +38,30 @@ class Resource extends Entity implements IResource {
 
     return super.isValid() && this.data.isValid();
   }
+
+  /**
+   * find resource entity data by document id value - 1:1 relation,
+   * so even if more > 1 results are found, return the first one
+   * @param conn
+   * @param docId
+   * @returns
+   */
+  static async findByDocumentId(
+    conn: Connection,
+    docId: string
+  ): Promise<IResource | null> {
+    const result = await rethink
+      .table(Entity.table)
+      .filter({
+        class: EntityEnums.Class.Resource,
+        data: {
+          documentId: docId,
+        },
+      })
+      .run(conn);
+
+    return result && result.length ? (result[0] as IResource) : null;
+  }
 }
 
 export default Resource;
diff --git a/packages/server/src/models/setting/setting.ts b/packages/server/src/models/setting/setting.ts
new file mode 100644
index 000000000..00e96ddad
--- /dev/null
+++ b/packages/server/src/models/setting/setting.ts
@@ -0,0 +1,88 @@
+import { r as rethink, Connection, WriteResult } from "rethinkdb-ts";
+import { IDbModel } from "@models/common";
+import { ISetting, SettingsKey } from "@shared/types/settings";
+
+export class Setting implements ISetting, IDbModel {
+  id: string;
+  value: unknown;
+  public: boolean;
+
+  static table = "settings";
+
+  constructor(data: ISetting) {
+    this.id = data.id;
+    this.value = data.value;
+    this.public = !!data.public;
+  }
+
+  isValid(): boolean {
+    return !!this.id;
+  }
+
+  async save(dbInstance: Connection | undefined): Promise<boolean> {
+    const result = await rethink
+      .table(Setting.table)
+      .insert(
+        {
+          id: this.id,
+          value: this.value,
+          public: this.public,
+        },
+        { conflict: "update" } // use upsert
+      )
+      .run(dbInstance);
+
+    return result.inserted === 1;
+  }
+
+  update(
+    dbInstance: Connection | undefined,
+    updateData: { value: any }
+  ): Promise<WriteResult> {
+    return rethink
+      .table(Setting.table)
+      .get(this.id)
+      .replace({ ...updateData, id: this.id, public: this.public })
+      .run(dbInstance);
+  }
+
+  delete(dbInstance: Connection): Promise<WriteResult> {
+    throw new Error("Setting cannot be removed");
+  }
+
+  static async getSetting(
+    conn: Connection,
+    key: SettingsKey
+  ): Promise<Setting | null> {
+    const result = await rethink.table(Setting.table).get(key).run(conn);
+    return result ? new Setting(result as ISetting) : null;
+  }
+
+  static async getSettings(
+    conn: Connection,
+    keys: string[]
+  ): Promise<Setting[]> {
+    const results = await rethink
+      .table(Setting.table)
+      .getAll.apply(undefined, keys)
+      .run(conn);
+    return results.map((data) => new Setting(data));
+  }
+
+  static async updateGroup(
+    conn: Connection,
+    allowedSettingsKeys: string[],
+    data: { id: string; value: unknown }[]
+  ): Promise<boolean> {
+    for (const entry of data) {
+      if (allowedSettingsKeys.includes(entry.id)) {
+        await new Setting({
+          id: entry.id,
+          value: entry.value,
+          public: false,
+        }).save(conn);
+      }
+    }
+    return true;
+  }
+}
diff --git a/packages/server/src/models/statement/response.ts b/packages/server/src/models/statement/response.ts
index 010bcb3c2..a8050276c 100644
--- a/packages/server/src/models/statement/response.ts
+++ b/packages/server/src/models/statement/response.ts
@@ -1,11 +1,11 @@
 import { EntityEnums, UserEnums } from "@shared/enums";
 import {
   IAction,
+  IConcept,
   IEntity,
   IResponseStatement,
   IStatement,
   ITerritory,
-  Relation,
 } from "@shared/types";
 import {
   IWarning,
@@ -14,21 +14,18 @@ import {
 } from "@shared/types/warning";
 
 import { ActionEntity } from "@models/action/action";
-import { getEntityClass } from "@models/factory";
-import { findEntityById } from "@service/shorthands";
+import Classification from "@models/relation/classification";
+import { findEntityById, getEntitiesByIds } from "@service/shorthands";
 import treeCache from "@service/treeCache";
 import { WarningTypeEnums } from "@shared/enums";
 import { InternalServerError } from "@shared/types/errors";
-import {
-  EProtocolTieType,
-  ITerritoryValidation,
-} from "@shared/types/territory";
+import { ITerritoryValidation } from "@shared/types/territory";
 import { Connection } from "rethinkdb-ts";
 import { IRequest } from "src/custom_typings/request";
 import Entity from "../entity/entity";
 import { PositionRules } from "./PositionRules";
 import Statement from "./statement";
-import Classification from "@models/relation/classification";
+import { PropSpecKind } from "@shared/types/prop";
 
 export class ResponseStatement extends Statement implements IResponseStatement {
   entities: { [key: string]: IEntity };
@@ -171,20 +168,7 @@ export class ResponseStatement extends Statement implements IResponseStatement {
   async getTValidationWarnings(req: IRequest): Promise<IWarning[]> {
     let warnings: IWarning[] = [];
 
-    // console.log("");
-    // console.log("!!! VALIDATION !!!", this.id);
-
-    const parentTId = this.data.territory?.territoryId as string;
-
-    const checkItems: {
-      entity: Entity;
-      classifications: Relation.IConnection<
-        Relation.IClassification,
-        Relation.ISuperclass
-      >[];
-    }[] = [];
-
-    const allEntities = [
+    let allEntities = [
       ...this.data.actants.map((a) => a.entityId),
       ...this.data.actions.map((a) => a.actionId),
       this.id, // statement itself
@@ -193,6 +177,8 @@ export class ResponseStatement extends Statement implements IResponseStatement {
     this.data.actants.forEach((a) => {
       allEntities.push(...a.classifications.map((c) => c.entityId));
       allEntities.push(...a.identifications.map((c) => c.entityId));
+
+      // todo go deeper
       allEntities.push(...a.props.map((c) => c.type.entityId));
       allEntities.push(...a.props.map((c) => c.value.entityId));
     });
@@ -201,16 +187,23 @@ export class ResponseStatement extends Statement implements IResponseStatement {
       allEntities.push(...a.props.map((c) => c.value.entityId));
     });
 
-    // prepare entities
-    for (const ai in allEntities) {
-      const entityId = allEntities[ai];
+    allEntities = [...new Set(allEntities)];
 
+    const parentTId = this.data.territory?.territoryId as string;
+    const lineageTIds = [parentTId, ...treeCache.tree.idMap[parentTId].path];
+    const territoryEs = await getEntitiesByIds<ITerritory>(
+      req.db.connection,
+      lineageTIds
+    );
+
+    // prepare entities
+    for (const ei in allEntities) {
+      const entityId = allEntities[ei];
       if (entityId) {
         const entityData = await this.obtainEntity(entityId, req);
-        const entityModel = getEntityClass({ ...entityData });
-        const entity = new Entity(entityModel);
+        const entity = new Entity(entityData);
 
-        const classifications =
+        const classificationRels =
           await Classification.getClassificationForwardConnections(
             req.db.connection,
             entityId,
@@ -218,200 +211,26 @@ export class ResponseStatement extends Statement implements IResponseStatement {
             1,
             0
           );
-        checkItems.push({
-          entity,
-          classifications: classifications,
-        });
-      }
-    }
-
-    if (parentTId) {
-      const lineageTIds = [parentTId, ...treeCache.tree.idMap[parentTId].path];
-
-      for (const tId of lineageTIds) {
-        const tEntity = (await this.obtainEntity(tId, req)) as ITerritory;
-        const tValidations = tEntity.data.validations?.filter(
-          (v) => v.active !== false
+        const classificationEs: IConcept[] = await getEntitiesByIds<IConcept>(
+          req.db.connection,
+          classificationRels.map((c) => c.entityIds[1])
         );
-
-        for (const tValidation of tValidations ?? []) {
-          const {
-            entityClasses,
-            classifications,
-            tieType,
-            propType,
-            allowedClasses,
-            allowedEntities,
-          } = tValidation;
-
-          const addNewValidationWarning = (
-            entityId: string,
-            code: WarningTypeEnums
-          ) => {
-            warnings.push(
-              this.newStatementWarning(
-                code,
-                {
-                  section: IWarningPositionSection.Statement,
-                  subSection: `statement`,
-                  entityId: entityId,
-                },
-                tValidation
-              )
-            );
-          };
-
-          const entitiesToCheck = checkItems
-            .filter((check) => {
-              return entityClasses?.includes(check.entity.class);
-            })
-            .filter((check) => {
-              // falls under classification condition
-              if (!classifications || !classifications.length) {
-                // there is no classification condition
-                return true;
-              }
-              const claEntities = check.classifications
-                ?.map((c) => c.entityIds[1])
-                .filter((c) => c);
-
-              // at least one required classifications is fullfilled
-              return classifications.some((classCondition) =>
-                claEntities?.includes(classCondition)
-              );
-            });
-
-          for (const ei in entitiesToCheck) {
-            const { entity, classifications: eClassifications } =
-              entitiesToCheck[ei];
-            // CLASSIFICATION TIE
-            if (tieType === EProtocolTieType.Classification) {
-              if (!allowedEntities || !allowedEntities.length) {
-                // no condition set, so we need at least one classification
-                if (!eClassifications.length) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVEC);
-                }
-              } else {
-                // classifications of the entity
-                const claEntities = eClassifications
-                  ?.map((c) => c.entityIds[1])
-                  .filter((c) => c);
-                if (
-                  !allowedEntities.some((classCondition) =>
-                    claEntities?.includes(classCondition)
-                  )
-                ) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVECE);
-                }
-              }
-            }
-
-            // REFERENCE TIE
-            else if (tieType === EProtocolTieType.Reference) {
-              const eReferences = entity.references.filter(
-                (r) => r.resource && r.value
-              );
-              // at least one reference (any) needs to be assigned to the E
-              if (!allowedEntities || !allowedEntities.length) {
-                if (eReferences.length === 0) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVER);
-                }
-              } else {
-                // at least one reference needs to be of the allowed entity
-                if (
-                  !eReferences.some((r) =>
-                    allowedEntities?.includes(r.resource)
-                  )
-                ) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVERE);
-                }
-              }
-            }
-
-            // PROPERTY TIE
-            else if (tieType === EProtocolTieType.Property) {
-              const eProps = entity.props.filter(
-                (p) => p.value.entityId && p.type.entityId
-              );
-
-              // at least one property needs to be assigned to the E
-              if (
-                !propType ||
-                (!propType.length &&
-                  !allowedEntities?.length &&
-                  !allowedClasses?.length)
-              ) {
-                if (eProps.length === 0) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVEP);
-                }
-
-                // type is defined but value is empty
-              } else if (
-                propType?.length &&
-                !allowedEntities?.length &&
-                !allowedClasses?.length
-              ) {
-                if (
-                  eProps.length === 0 ||
-                  !eProps.some((p) => propType?.includes(p.type.entityId))
-                ) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVEPT);
-                }
-              } else if (allowedEntities?.length || allowedClasses?.length) {
-                const validProps = eProps.filter((p) =>
-                  propType?.length ? propType.includes(p.type.entityId) : true
-                );
-                if (!validProps?.length) {
-                  addNewValidationWarning(entity.id, WarningTypeEnums.TVEPV);
-                } else if (allowedClasses?.length) {
-                  // class is required
-
-                  // no valid props
-                  if (validProps.length === 0) {
-                    addNewValidationWarning(entity.id, WarningTypeEnums.TVEPV);
-                  } else {
-                    let passed = true;
-                    for (const pi in eProps) {
-                      const p = eProps[pi];
-                      const propValueEntityId = p.value.entityId;
-                      const propValueEntity = await findEntityById(
-                        req.db,
-                        propValueEntityId
-                      );
-                      if (
-                        propType?.includes(p.type.entityId) &&
-                        !allowedClasses?.includes(propValueEntity.class)
-                      ) {
-                        passed = false;
-                      }
-                    }
-                    if (!passed) {
-                      addNewValidationWarning(
-                        entity.id,
-                        WarningTypeEnums.TVEPV
-                      );
-                    }
-                  }
-                } else if (allowedEntities?.length) {
-                  // entity is required
-                  if (validProps.length === 0) {
-                    addNewValidationWarning(entity.id, WarningTypeEnums.TVEPV);
-                  } else if (
-                    !validProps.some((p) =>
-                      allowedEntities.includes(p.value.entityId)
-                    )
-                  ) {
-                    addNewValidationWarning(entity.id, WarningTypeEnums.TVEPV);
-                  }
-                }
-              }
-            }
-          }
+        const propValueEs = await getEntitiesByIds<IEntity>(
+          req.db.connection,
+          Entity.extractIdsFromProps(entity.props, [PropSpecKind.VALUE])
+        );
+        const eWarnings = entity.getTBasedWarnings(
+          territoryEs,
+          classificationEs,
+          propValueEs
+        );
+        if (eWarnings.length) {
+          warnings = warnings.concat(eWarnings);
         }
       }
     }
 
-    // console.log(warnings);
+    console.log(warnings);
     return warnings;
   }
 
diff --git a/packages/server/src/models/statement/statement.test.ts b/packages/server/src/models/statement/statement.test.ts
index 074a818e8..89bb234d5 100644
--- a/packages/server/src/models/statement/statement.test.ts
+++ b/packages/server/src/models/statement/statement.test.ts
@@ -142,7 +142,7 @@ describe("models/statement", function () {
     });
 
     describe("insert one child without explicit order", () => {
-      it("should have order = 0", async (done) => {
+      it("should have order = 0", async () => {
         const statement = new Statement({});
         statement.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -154,13 +154,11 @@ describe("models/statement", function () {
           statement.data.territory?.territoryId
         );
         expect(createdData.data.territory?.order).toEqual(0);
-
-        done();
       });
     });
 
     describe("insert one child with explicit order", () => {
-      it("should have order = 999 as wanted", async (done) => {
+      it("should have order = 999 as wanted", async () => {
         const statement = new Statement({});
         statement.data = new StatementData({
           territory: { territoryId: "any", order: 999 },
@@ -174,13 +172,11 @@ describe("models/statement", function () {
         expect(createdData.data.territory?.order).toEqual(
           statement.data.territory?.order
         );
-
-        done();
       });
     });
 
     describe("insert two child without explicit order", () => {
-      it("should have order = 0 and 1 respectively", async (done) => {
+      it("should have order = 0 and 1 respectively", async () => {
         const statement1 = new Statement({});
         statement1.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -214,7 +210,6 @@ describe("models/statement", function () {
           createdData2.data.territory?.territoryId
         );
         expect(createdData2.data.territory?.order).toEqual(1);
-        done();
       });
     });
   });
@@ -235,7 +230,7 @@ describe("models/statement", function () {
     });
 
     describe("update the only child", () => {
-      it("should have order = 0", async (done) => {
+      it("should have order = 0", async () => {
         const statement = new Statement({});
         statement.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -248,13 +243,11 @@ describe("models/statement", function () {
         });
         const createdData = await findEntityById<IStatement>(db, statement.id);
         expect(createdData.data.territory?.order).toEqual(0);
-
-        done();
       });
     });
 
     describe("update the second's order value without conflict ", () => {
-      it("should have order as chosen", async (done) => {
+      it("should have order as chosen", async () => {
         const statement1 = new Statement({});
         statement1.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -274,13 +267,11 @@ describe("models/statement", function () {
 
         const createdData = await findEntityById<IStatement>(db, statement2.id);
         expect(createdData.data.territory?.order).toEqual(wantedNewOrder);
-
-        done();
       });
     });
 
     describe("update the second's order value (conflict)", () => {
-      it("should have order as before", async (done) => {
+      it("should have order as before", async () => {
         const statement1 = new Statement({});
         statement1.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -310,13 +301,11 @@ describe("models/statement", function () {
           statement1.id
         );
         expect(createdData1.data.territory?.order).toEqual(0);
-
-        done();
       });
     });
 
     describe("update the third's order value (conflict)", () => {
-      it("should have non conflicting order", async (done) => {
+      it("should have non conflicting order", async () => {
         const statement1 = new Statement({});
         statement1.data = new StatementData({
           territory: { territoryId: "any", order: 0 },
@@ -364,8 +353,6 @@ describe("models/statement", function () {
           statement3.id
         );
         expect(createdData3.data.territory?.order).toEqual(0.5);
-
-        done();
       });
     });
   });
@@ -420,10 +407,9 @@ describe("models/statement", function () {
     });
 
     describe("empty db", () => {
-      it("should return empty array", async (done) => {
+      it("should return empty array", async () => {
         const statements = await Statement.getLinkedEntities(db.connection, "");
         expect(statements).toHaveLength(0);
-        done();
       });
     });
 
@@ -760,7 +746,7 @@ describe("models/statement", function () {
     beforeAll(async () => {
       await db.initDb();
       await createMockTree(db, randSuffix);
-      treeCache.tree = await treeCache.createTree(db);
+      treeCache.tree = await treeCache.createTree();
     });
 
     afterAll(async () => {
@@ -910,7 +896,7 @@ describe("models/statement", function () {
     beforeAll(async () => {
       await db.initDb();
       await createMockTree(db, randSuffix);
-      treeCache.tree = await treeCache.createTree(db);
+      treeCache.tree = await treeCache.createTree();
     });
 
     afterAll(async () => {
@@ -1146,7 +1132,7 @@ describe("models/statement", function () {
     beforeAll(async () => {
       await db.initDb();
       await createMockTree(db, randSuffix);
-      treeCache.tree = await treeCache.createTree(db);
+      treeCache.tree = await treeCache.createTree();
     });
 
     afterAll(async () => {
diff --git a/packages/server/src/models/statement/statement.ts b/packages/server/src/models/statement/statement.ts
index 16c80c7e1..5ebd464fb 100644
--- a/packages/server/src/models/statement/statement.ts
+++ b/packages/server/src/models/statement/statement.ts
@@ -25,6 +25,7 @@ import {
   StatementObject,
 } from "@shared/types/statement";
 import { randomUUID } from "crypto";
+import { PropSpecKind } from "@shared/types/prop";
 
 export class StatementClassification implements IStatementClassification {
   id = "";
@@ -255,7 +256,7 @@ class Statement extends Entity implements IStatement {
    */
   canBeEditedByUser(user: User): boolean {
     // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -296,7 +297,7 @@ class Statement extends Entity implements IStatement {
    */
   canBeViewedByUser(user: User): boolean {
     // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -322,7 +323,7 @@ class Statement extends Entity implements IStatement {
    */
   canBeDeletedByUser(user: User): boolean {
     // only admin has the right, no matter the territory
-    if (user.role === UserEnums.Role.Admin) {
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -507,14 +508,22 @@ class Statement extends Entity implements IStatement {
 
   walkObjects(cb: (o: StatementObject) => void) {
     // statement.props
-    Entity.extractIdsFromProps(this.props, cb);
+    Entity.extractIdsFromProps(
+      this.props,
+      [PropSpecKind.TYPE, PropSpecKind.VALUE],
+      cb
+    );
 
     // statement.actions
     for (const action of this.data.actions) {
       cb(action);
 
       // statement.actions.props
-      Entity.extractIdsFromProps(action.props, cb);
+      Entity.extractIdsFromProps(
+        action.props,
+        [PropSpecKind.TYPE, PropSpecKind.VALUE],
+        cb
+      );
     }
 
     // statement.actants
@@ -522,7 +531,11 @@ class Statement extends Entity implements IStatement {
       cb(actant);
 
       // statement.actants.props
-      Entity.extractIdsFromProps(actant.props, cb);
+      Entity.extractIdsFromProps(
+        actant.props,
+        [PropSpecKind.TYPE, PropSpecKind.VALUE],
+        cb
+      );
 
       // statement.actants.classifications
       for (const classification of actant.classifications) {
diff --git a/packages/server/src/models/territory/territory.ts b/packages/server/src/models/territory/territory.ts
index 5abcada5b..d1de31e6d 100644
--- a/packages/server/src/models/territory/territory.ts
+++ b/packages/server/src/models/territory/territory.ts
@@ -293,8 +293,8 @@ class Territory extends Entity implements ITerritory {
   }
 
   canBeViewedByUser(user: User): boolean {
-    // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    // admin/owner role has always the right
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -307,8 +307,8 @@ class Territory extends Entity implements ITerritory {
   }
 
   canBeEditedByUser(user: User): boolean {
-    // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    // admin/owner role has always the right
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -329,8 +329,8 @@ class Territory extends Entity implements ITerritory {
   }
 
   canBeCreatedByUser(user: User): boolean {
-    // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    // admin/owner role has always the right
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
@@ -364,8 +364,8 @@ class Territory extends Entity implements ITerritory {
   }
 
   canBeDeletedByUser(user: User): boolean {
-    // admin role has always the right
-    if (user.role === UserEnums.Role.Admin) {
+    // admin/owner role has always the right
+    if (user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin])) {
       return true;
     }
 
diff --git a/packages/server/src/models/user/user.ts b/packages/server/src/models/user/user.ts
index 76554ee5e..6c09787c1 100644
--- a/packages/server/src/models/user/user.ts
+++ b/packages/server/src/models/user/user.ts
@@ -9,8 +9,8 @@ import { r as rethink, Connection, WriteResult, RDatum } from "rethinkdb-ts";
 import { IDbModel, fillArray, fillFlatObject } from "@models/common";
 import { EntityEnums, UserEnums } from "@shared/enums";
 import { ModelNotValidError } from "@shared/types/errors";
-import { generateRandomString, generateUuid, hashPassword } from "@common/auth";
-import { generatePassword, regExpEscape } from "@common/functions";
+import { generateUuid, hashPassword } from "@common/auth";
+import { generatePassword } from "@common/functions";
 import { nonenumerable } from "@common/decorators";
 import { Db } from "@service/rethink";
 
@@ -166,13 +166,17 @@ export default class User implements IUser, IDbModel {
 
   /**
    * Soft delete operation - set deletedAt to current date, value indicated deleted user
-   * @param dbInstance 
-   * @returns 
+   * @param dbInstance
+   * @returns
    */
   delete(dbInstance: Connection): Promise<WriteResult> {
-    return rethink.table(User.table).get(this.id).update({
-      deletedAt: new Date()
-    }).run(dbInstance);
+    return rethink
+      .table(User.table)
+      .get(this.id)
+      .update({
+        deletedAt: new Date(),
+      })
+      .run(dbInstance);
   }
 
   isValid(): boolean {
@@ -193,15 +197,18 @@ export default class User implements IUser, IDbModel {
   }
 
   canBeCreatedByUser(user: User): boolean {
-    return user.role === UserEnums.Role.Admin;
+    return user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin]);
   }
 
   canBeEditedByUser(user: User): boolean {
-    return user.role === UserEnums.Role.Admin || user.id == this.id;
+    return (
+      user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin]) ||
+      user.id == this.id
+    );
   }
 
   canBeDeletedByUser(user: User): boolean {
-    return user.role === UserEnums.Role.Admin;
+    return user.hasRole([UserEnums.Role.Owner, UserEnums.Role.Admin]);
   }
 
   generatePassword(): string {
@@ -223,9 +230,9 @@ export default class User implements IUser, IDbModel {
   /**
    * Finds user by 'id' field
    * Ignores thrashed entries
-   * @param dbInstance 
-   * @param id 
-   * @returns 
+   * @param dbInstance
+   * @param id
+   * @returns
    */
   static async findUserById(
     dbInstance: Connection | undefined,
@@ -240,12 +247,27 @@ export default class User implements IUser, IDbModel {
     return new User(data);
   }
 
+  /**
+   * Returns first owner-role based user or null
+   * @param dbInstance
+   * @returns
+   */
+  static async getOwner(
+    dbInstance: Connection | undefined
+  ): Promise<User | null> {
+    const data = await rethink
+      .table(User.table)
+      .filter({ role: UserEnums.Role.Owner })
+      .run(dbInstance);
+    return data && data.length > 0 ? new User(data[0]) : null;
+  }
+
   /**
    * Finds user identified by 'email' field
    * Ignores thrashed entries
-   * @param dbInstance 
-   * @param email 
-   * @returns 
+   * @param dbInstance
+   * @param email
+   * @returns
    */
   static async getUserByEmail(
     dbInstance: Connection | undefined,
@@ -253,8 +275,8 @@ export default class User implements IUser, IDbModel {
   ): Promise<User | null> {
     const data = await rethink
       .table(User.table)
-      .filter(function(user: any) {
-        return rethink.not(user.hasFields("deletedAt"))
+      .filter(function (user: any) {
+        return rethink.not(user.hasFields("deletedAt"));
       })
       .filter({ email })
       .limit(1)
@@ -268,9 +290,9 @@ export default class User implements IUser, IDbModel {
   /**
    * Finds user identified by 'hash' field
    * Ignores thrashed entries
-   * @param dbInstance 
-   * @param hash 
-   * @returns 
+   * @param dbInstance
+   * @param hash
+   * @returns
    */
   static async getUserByHash(
     dbInstance: Connection | undefined,
@@ -278,8 +300,8 @@ export default class User implements IUser, IDbModel {
   ): Promise<User | null> {
     const data = await rethink
       .table(User.table)
-      .filter(function(user: any) {
-        return rethink.not(user.hasFields("deletedAt"))
+      .filter(function (user: any) {
+        return rethink.not(user.hasFields("deletedAt"));
       })
       .filter({ hash })
       .run(dbInstance);
@@ -292,16 +314,16 @@ export default class User implements IUser, IDbModel {
   /**
    * Returns all users
    * Ignores thrashed entries
-   * @param dbInstance 
-   * @returns 
+   * @param dbInstance
+   * @returns
    */
   static async findAllUsers(
     dbInstance: Connection | undefined
   ): Promise<User[]> {
     const data = await rethink
       .table(User.table)
-      .filter(function(user: any) {
-        return rethink.not(user.hasFields("deletedAt"))
+      .filter(function (user: any) {
+        return rethink.not(user.hasFields("deletedAt"));
       })
       .orderBy(rethink.asc("role"), rethink.asc("name"))
       .run(dbInstance);
@@ -321,16 +343,16 @@ export default class User implements IUser, IDbModel {
     login: string,
     includeThrashed: boolean
   ): Promise<User | null> {
-    let req = await rethink
-      .table(User.table);
+    let req = await rethink.table(User.table);
 
     if (!includeThrashed) {
-      req = req.filter(function(user: any) {
-        return rethink.not(user.hasFields("deletedAt"))
+      req = req.filter(function (user: any) {
+        return rethink.not(user.hasFields("deletedAt"));
       });
     }
 
-    const data = await req.filter(function (user: any) {
+    const data = await req
+      .filter(function (user: any) {
         return rethink.or(
           rethink.row("name").eq(login),
           rethink.row("email").eq(login)
@@ -345,9 +367,9 @@ export default class User implements IUser, IDbModel {
   /**
    * Returns users by cleaned label (for name / email).
    * Does not return thrashed users.
-   * @param dbInstance 
-   * @param label 
-   * @returns 
+   * @param dbInstance
+   * @param label
+   * @returns
    */
   static async findUsersByLabel(
     dbInstance: Connection | undefined,
@@ -355,7 +377,7 @@ export default class User implements IUser, IDbModel {
   ): Promise<User[]> {
     const data = await rethink
       .table(User.table)
-     
+
       .run(dbInstance);
     return (data as IUser[]).map((d) => new User(d));
   }
@@ -446,4 +468,8 @@ export default class User implements IUser, IDbModel {
       });
     }
   }
+
+  hasRole(allowed: UserEnums.Role[]): boolean {
+    return allowed.indexOf(this.role) !== -1;
+  }
 }
diff --git a/packages/server/src/modules/audits/audits.get.test.ts b/packages/server/src/modules/audits/audits.get.test.ts
new file mode 100644
index 000000000..2e5cef7d6
--- /dev/null
+++ b/packages/server/src/modules/audits/audits.get.test.ts
@@ -0,0 +1,50 @@
+import { testErroneousResponse } from "@modules/common.test";
+import { DocumentDoesNotExist } from "@shared/types/errors";
+import request from "supertest";
+import { supertestConfig } from "..";
+import { apiPath } from "@common/constants";
+import app from "../../Server";
+import { Db } from "@service/rethink";
+import { pool } from "@middlewares/db";
+import Audit from "@models/audit/audit";
+
+describe("modules/audits GET", function () {
+  const db = new Db();
+  const firstAudit1980 = new Audit({ date: new Date("1980") });
+  const secondAudit1990 = new Audit({ date: new Date("1990") });
+  const secondAudit2000 = new Audit({ date: new Date("2000") });
+
+  beforeAll(async () => {
+    await db.initDb();
+    firstAudit1980.save(db.connection);
+    secondAudit1990.save(db.connection);
+    secondAudit2000.save(db.connection);
+  });
+
+  afterAll(async () => {
+    await db.close();
+    await pool.end();
+  });
+
+  describe("Without params", () => {
+    it("should return a first audit nonetheless", async () => {
+      const response = await request(app)
+        .get(`${apiPath}/audits`)
+        .set("authorization", "Bearer " + supertestConfig.token)
+        .expect(200);
+
+      expect(new Date(response.body.data.date)).toEqual(firstAudit1980.date);
+    });
+  });
+
+  describe("With specific date param", () => {
+    it("should return a 2000 audit", async () => {
+      const response = await request(app)
+        .get(`${apiPath}/audits?from=2000`)
+        .set("authorization", "Bearer " + supertestConfig.token)
+        .expect(200);
+
+      expect(new Date(response.body.data.date)).toEqual(secondAudit2000.date);
+    });
+  });
+});
diff --git a/packages/server/src/modules/audits/index.ts b/packages/server/src/modules/audits/index.ts
index 5f0e0038a..20e2bb230 100644
--- a/packages/server/src/modules/audits/index.ts
+++ b/packages/server/src/modules/audits/index.ts
@@ -1,10 +1,15 @@
 import { asyncRouteHandler } from "../index";
 import { Router } from "express";
 import { findEntityById } from "@service/shorthands";
-import { BadParams, AuditsDoNotExist } from "@shared/types/errors";
-import { IResponseAudit } from "@shared/types";
+import {
+  BadParams,
+  AuditsDoNotExist,
+  AuditDoesNotExist,
+} from "@shared/types/errors";
+import { IAudit, IResponseAudit, IResponseGeneric } from "@shared/types";
 import { ResponseAudit } from "@models/audit/response";
 import { IRequest } from "src/custom_typings/request";
+import Audit from "@models/audit/audit";
 
 export const getAuditByEntityId = asyncRouteHandler<IResponseAudit>(
   async (request: IRequest) => {
@@ -31,4 +36,30 @@ export const getAuditByEntityId = asyncRouteHandler<IResponseAudit>(
   }
 );
 
-export default Router()
+export default Router().get(
+  "/",
+  asyncRouteHandler<IResponseGeneric<IAudit>>(
+    async (
+      request: IRequest<
+        unknown,
+        unknown,
+        { skip: number; take: number; from: string }
+      >
+    ) => {
+      const firstAudits = await Audit.findMany(request.db.connection, {
+        skip: request.query.skip || 0,
+        take: request.query.take || 1,
+        from: new Date(request.query.from || "1970"),
+      });
+
+      if (!firstAudits || !firstAudits.length) {
+        throw new AuditDoesNotExist("no audit found");
+      }
+
+      return {
+        result: true,
+        data: firstAudits[0],
+      };
+    }
+  )
+);
diff --git a/packages/server/src/modules/documents/documents.delete.test.ts b/packages/server/src/modules/documents/documents.delete.test.ts
index fe2f2d1ab..3c89176a9 100644
--- a/packages/server/src/modules/documents/documents.delete.test.ts
+++ b/packages/server/src/modules/documents/documents.delete.test.ts
@@ -49,7 +49,7 @@ describe("modules/documents DELETE", function () {
         .expect("Content-Type", /json/)
         .expect(200)
         .expect(async () => {
-          const deleted = await Document.findDocumentById(
+          const deleted = await Document.getDocumentById(
             db.connection,
             document.id
           );
diff --git a/packages/server/src/modules/documents/documents.update.test.ts b/packages/server/src/modules/documents/documents.update.test.ts
index 1cc71bd08..d86b371f1 100644
--- a/packages/server/src/modules/documents/documents.update.test.ts
+++ b/packages/server/src/modules/documents/documents.update.test.ts
@@ -62,7 +62,7 @@ describe("modules/documents UPDATE", function () {
         .expect(200)
         .expect(successfulGenericResponse)
         .expect(async () => {
-          const changedEntry = await Document.findDocumentById(
+          const changedEntry = await Document.getDocumentById(
             db.connection,
             document.id
           );
diff --git a/packages/server/src/modules/documents/index.ts b/packages/server/src/modules/documents/index.ts
index f2d654b26..43431c0cc 100644
--- a/packages/server/src/modules/documents/index.ts
+++ b/packages/server/src/modules/documents/index.ts
@@ -73,7 +73,7 @@ export default Router()
 
     console.log("EXPORTING");
 
-    const existing = await Document.findDocumentById(request.db.connection, id);
+    const existing = await Document.getDocumentById(request.db.connection, id);
 
     if (!existing) {
       throw DocumentDoesNotExist.forId(id);
@@ -150,7 +150,7 @@ export default Router()
         throw new BadParams("document id has to be set");
       }
 
-      const existing = await Document.findDocumentById(
+      const existing = await Document.getDocumentById(
         request.db.connection,
         id
       );
@@ -260,7 +260,7 @@ export default Router()
       await request.db.lock();
 
       // documentId must be already in the db
-      const existingDocument = await Document.findDocumentById(
+      const existingDocument = await Document.getDocumentById(
         request.db.connection,
         documentId
       );
@@ -326,7 +326,7 @@ export default Router()
 
       await request.db.lock();
 
-      const existing = await Document.findDocumentById(
+      const existing = await Document.getDocumentById(
         request.db.connection,
         id
       );
@@ -350,4 +350,41 @@ export default Router()
         throw new InternalServerError(`cannot delete document ${id}`);
       }
     })
+  )
+  .patch(
+    "/:documentId/removeAnchors",
+    asyncRouteHandler<IResponseGeneric>(
+      async (
+        request: IRequest<{ documentId: string }, unknown, { entityId: string }>
+      ) => {
+        const id = request.params.documentId;
+        if (!id) {
+          throw new BadParams("document id has to be set");
+        }
+
+        await request.db.lock();
+
+        const existing = await Document.getDocumentById(
+          request.db.connection,
+          id
+        );
+        if (!existing) {
+          throw DocumentDoesNotExist.forId(id);
+        }
+
+        let entityIds: string[] | string = request.query.entityId;
+        existing.removeAnchors(
+          typeof entityIds === "object" ? entityIds : [entityIds]
+        );
+
+        const result = await existing.update(request.db.connection, {
+          content: existing.content,
+          entityIds: existing.entityIds,
+        });
+
+        return {
+          result: !!result.replaced,
+        };
+      }
+    )
   );
diff --git a/packages/server/src/modules/settings/index.ts b/packages/server/src/modules/settings/index.ts
new file mode 100644
index 000000000..5d9a5188e
--- /dev/null
+++ b/packages/server/src/modules/settings/index.ts
@@ -0,0 +1,155 @@
+import { Router } from "express";
+import {
+  BadParams,
+  InternalServerError,
+  ModelNotValidError,
+  NotFound,
+} from "@shared/types/errors";
+import { asyncRouteHandler } from "..";
+import { IResponseGeneric } from "@shared/types";
+import { IRequest } from "src/custom_typings/request";
+import { ISetting, ISettingGroup, SettingsKey } from "@shared/types/settings";
+import { Setting } from "@models/setting/setting";
+import { SettingGroupDict } from "@shared/dictionaries/settinggroup";
+
+export default Router()
+  .put(
+    "/group/:groupkey",
+    asyncRouteHandler<IResponseGeneric<ISettingGroup>>(
+      async (
+        request: IRequest<
+          { groupkey: string },
+          { id: string; value: unknown }[]
+        >
+      ) => {
+        const groupkey = request.params.groupkey as string;
+        const data = request.body;
+
+        if (!groupkey) {
+          throw new BadParams("invalid group setting key");
+        }
+        const dictItem = SettingGroupDict.find((item) => item.id === groupkey);
+        if (!dictItem) {
+          throw new NotFound(`No group with key ${groupkey} found`);
+        }
+
+        return {
+          result: await Setting.updateGroup(request.db.connection, dictItem.value, data),
+        };
+      }
+    )
+  )
+  .get(
+    "/group/:groupkey",
+    asyncRouteHandler<IResponseGeneric<ISettingGroup>>(
+      async (request: IRequest<{ groupkey: string }>) => {
+        const groupkey = request.params.groupkey as string;
+
+        if (!groupkey) {
+          throw new BadParams("invalid group setting key");
+        }
+        const dict = [...SettingGroupDict];
+        const dictItem = dict.find((item) => item.id === groupkey);
+        if (!dictItem) {
+          throw new NotFound(`No group with key ${groupkey} found`);
+        }
+
+        const settings = await Setting.getSettings(
+          request.db.connection,
+          dictItem.value
+        );
+
+        return {
+          result: true,
+          data: {
+            id: groupkey,
+            settings: settings.filter((setting) => !!setting),
+          },
+        };
+      }
+    )
+  )
+  .get(
+    "/:key",
+    asyncRouteHandler<IResponseGeneric<ISetting>>(
+      async (request: IRequest<{ key: SettingsKey }>) => {
+        const key = request.params.key as SettingsKey;
+        if (
+          !key ||
+          // @ts-ignore
+          !new Setting({ id: key, public: false, value: null }).isValid()
+        ) {
+          throw new BadParams("invalid settings key");
+        }
+
+        const setting = await Setting.getSetting(request.db.connection, key);
+        if (!setting || (!request.user && !setting.public)) {
+          throw new NotFound("Entry not found");
+        }
+
+        return {
+          result: true,
+          data: setting,
+        };
+      }
+    )
+  )
+  .put(
+    "/:key",
+    asyncRouteHandler<IResponseGeneric>(
+      async (request: IRequest<{ key: string }>) => {
+        const settingKey = request.params.key as unknown as SettingsKey;
+        const data = request.body as { value: unknown };
+
+        // not validation, just required data for this operation
+        if (
+          !settingKey ||
+          !data ||
+          Object.keys(data).length === 0 ||
+          data.value === undefined
+        ) {
+          throw new BadParams("key and data have to be set");
+        }
+
+        await request.db.lock();
+
+        let existing = await Setting.getSetting(
+          request.db.connection,
+          settingKey
+        );
+
+        let result: boolean | undefined = undefined;
+
+        if (!existing) {
+          existing = new Setting({
+            id: settingKey as unknown as string,
+            ...data,
+          } as ISetting);
+          if (!existing.isValid()) {
+            throw new ModelNotValidError("Setting data is not valid");
+          }
+
+          result = await existing.save(request.db.connection);
+        } else {
+          existing.value = data.value;
+          if (!existing.isValid()) {
+            throw new ModelNotValidError("Setting data is not valid");
+          }
+
+          const updateResult = await existing.update(
+            request.db.connection,
+            data
+          );
+          result = updateResult?.replaced > 0 || updateResult?.unchanged > 0;
+        }
+
+        if (result) {
+          return {
+            result: true,
+          };
+        } else {
+          throw new InternalServerError(`cannot upsert setting ${settingKey}`);
+        }
+      }
+    )
+  );
diff --git a/packages/server/src/modules/settings/settings.updateGroup.test.ts b/packages/server/src/modules/settings/settings.updateGroup.test.ts
new file mode 100644
index 000000000..af4033f37
--- /dev/null
+++ b/packages/server/src/modules/settings/settings.updateGroup.test.ts
@@ -0,0 +1,71 @@
+import { testErroneousResponse } from "@modules/common.test";
+import { BadParams, NotFound, UserDoesNotExits } from "@shared/types/errors";
+import request from "supertest";
+import { apiPath } from "@common/constants";
+import app from "../../Server";
+import { createEntity } from "@service/shorthands";
+import { Db } from "@service/rethink";
+import Statement, {
+  StatementData,
+  StatementTerritory,
+} from "@models/statement/statement";
+import { supertestConfig } from "..";
+import User from "@models/user/user";
+import { IBookmarkFolder } from "@shared/types";
+import { pool } from "@middlewares/db";
+import { SettingGroupDict } from "@shared/dictionaries/settinggroup";
+import { globalValidationsDict } from "@shared/enums/warning";
+import { Setting } from "@models/setting/setting";
+
+describe("Settings updateGroup", function () {
+  const db = new Db();
+
+  beforeAll(async () => {
+    await db.initDb();
+  });
+
+  afterAll(async () => {
+    await db.close();
+    await pool.end();
+  });
+
+  describe("Not existing group param", () => {
+    it("should return a NotFound error wrapped in IResponseGeneric", async () => {
+      console.log(supertestConfig.token);
+      await request(app)
+        .put(`${apiPath}/settings/group/1224hjk`)
+        .set("authorization", "Bearer " + supertestConfig.token)
+        .expect(testErroneousResponse.bind(undefined, new NotFound("", "")));
+    });
+  });
+
+  describe("Existing group id", () => {
+    it("should return a 200 code even if not found setting entry id", async () => {
+      await request(app)
+        .put(`${apiPath}/settings/group/${SettingGroupDict[0].id}`)
+        .send([{ id: "nonexisting" }])
+        .set("authorization", "Bearer " + supertestConfig.token)
+        .expect(200);
+    });
+
+    it("should return a 200 code for updating 2 entries", async () => {
+      const id1 = Object.keys(globalValidationsDict)[0];
+      const value1 = Math.random();
+      const id2 = Object.keys(globalValidationsDict)[1];
+      const value2 = Math.random();
+      await request(app)
+        .put(`${apiPath}/settings/group/${SettingGroupDict[0].id}`)
+        .send([
+          { id: id1, value: value1 },
+          { id: id2, value: value2 },
+        ])
+        .set("authorization", "Bearer " + supertestConfig.token)
+        .expect(200);
+
+      const updated1 = await Setting.getSetting(db.connection, id1);
+      const updated2 = await Setting.getSetting(db.connection, id2);
+      expect(updated1?.value).toEqual(value1);
+      expect(updated2?.value).toEqual(value2);
+    });
+  });
+});
diff --git a/packages/server/src/modules/users/index.ts b/packages/server/src/modules/users/index.ts
index c843c7fa7..47855e846 100644
--- a/packages/server/src/modules/users/index.ts
+++ b/packages/server/src/modules/users/index.ts
@@ -7,6 +7,7 @@ import {
   EmailError,
   InternalServerError,
   ModelNotValidError,
+  NotFound,
   PasswordResetHashError,
   PermissionDeniedError,
   UserAlreadyActivated,
@@ -35,6 +36,20 @@ import { ResponseUser } from "@models/user/response";
 import { IRequest } from "src/custom_typings/request";
 
 export default Router()
+  .get(
+    "/owner",
+    asyncRouteHandler<IResponseGeneric<string>>(async (request: IRequest) => {
+      const owner = await User.getOwner(request.db.connection);
+      if (!owner) {
+        throw new NotFound("owner not found");
+      }
+
+      return {
+        result: true,
+        data: owner.email,
+      };
+    })
+  )
   /**
    * @openapi
    * /users/activation
diff --git a/packages/server/src/scripts/jwt.ts b/packages/server/src/scripts/jwt.ts
index 7cf438759..3cea25b22 100644
--- a/packages/server/src/scripts/jwt.ts
+++ b/packages/server/src/scripts/jwt.ts
@@ -10,7 +10,7 @@ import { Db } from "@service/rethink";
 
   const users = await User.findAllUsers(db.connection);
   users.forEach((u) => {
-    console.log(u.email, generateAccessToken(u, 365));
+    console.log(u.email, generateAccessToken(u, 365 * 10));
   });
 
   await db.close();
diff --git a/packages/server/src/service/shorthands.ts b/packages/server/src/service/shorthands.ts
index d6f79e177..f42616960 100644
--- a/packages/server/src/service/shorthands.ts
+++ b/packages/server/src/service/shorthands.ts
@@ -1,14 +1,14 @@
-import { Connection, r as rethink, RDatum, WriteResult } from "rethinkdb-ts";
-import { IEntity, IUser } from "@shared/types";
-import { Db } from "./rethink";
+import Audit from "@models/audit/audit";
 import { IDbModel } from "@models/common";
-import { ModelNotValidError } from "@shared/types/errors";
-import { DbEnums, EntityEnums } from "@shared/enums";
+import Document from "@models/document/document";
 import Entity from "@models/entity/entity";
-import User from "@models/user/user";
 import Relation from "@models/relation/relation";
-import Audit from "@models/audit/audit";
-import Document from "@models/document/document";
+import User from "@models/user/user";
+import { DbEnums, EntityEnums } from "@shared/enums";
+import { IEntity, IUser } from "@shared/types";
+import { ModelNotValidError } from "@shared/types/errors";
+import { Connection, RDatum, r as rethink, WriteResult } from "rethinkdb-ts";
+import { Db } from "./rethink";
 
 export async function getEntitiesDataByClass<T>(
   db: Connection,
@@ -30,6 +30,16 @@ export async function findEntityById<T extends IEntity>(
   return data || null;
 }
 
+export async function getEntitiesByIds<T extends IEntity>(
+  db: Connection,
+  ids: string[]
+): Promise<T[]> {
+  return rethink
+    .table(Entity.table)
+    .getAll(...ids)
+    .run(db);
+}
+
 export async function createEntity(db: Db, data: IDbModel): Promise<boolean> {
   if (!data.isValid()) {
     throw new ModelNotValidError("");
diff --git a/packages/shared/dictionaries/settinggroup.ts b/packages/shared/dictionaries/settinggroup.ts
new file mode 100644
index 000000000..7e1d93516
--- /dev/null
+++ b/packages/shared/dictionaries/settinggroup.ts
@@ -0,0 +1,9 @@
+import { SettingsKey } from "@shared/types/settings";
+import { globalValidationsDict } from "./../enums/warning";
+
+export const SettingGroupDict: { id: string; value: SettingsKey[] }[] = [
+  {
+    id: "validations",
+    value: Object.keys(globalValidationsDict),
+  },
+];
diff --git a/packages/shared/dictionaries/userroles.ts b/packages/shared/dictionaries/userroles.ts
index 77c4dd3f0..2a652c0f5 100644
--- a/packages/shared/dictionaries/userroles.ts
+++ b/packages/shared/dictionaries/userroles.ts
@@ -1,6 +1,11 @@
 import { UserEnums } from "../enums";
 
 export const userRoleDict = [
+  {
+    value: UserEnums.Role.Owner,
+    label: "owner",
+    info: "",
+  },
   {
     value: UserEnums.Role.Admin,
     label: "admin",
diff --git a/packages/shared/enums/users.ts b/packages/shared/enums/users.ts
index f465c1af7..dfdd6b758 100644
--- a/packages/shared/enums/users.ts
+++ b/packages/shared/enums/users.ts
@@ -1,13 +1,14 @@
 export namespace UserEnums {
-    export enum Role {
-        Admin = "admin",
-        Editor = "editor",
-        Viewer = "viewer",
-    }
+  export enum Role {
+    Owner = "owner",
+    Admin = "admin",
+    Editor = "editor",
+    Viewer = "viewer",
+  }
 
-    export enum RoleMode {
-        Write = "write",
-        Read = "read",
-        Admin = "admin",
-    }
-}
\ No newline at end of file
+  export enum RoleMode {
+    Write = "write",
+    Read = "read",
+    Admin = "admin",
+  }
+}
diff --git a/packages/shared/enums/warning.ts b/packages/shared/enums/warning.ts
index ef60f9ed6..c2b60b4b5 100644
--- a/packages/shared/enums/warning.ts
+++ b/packages/shared/enums/warning.ts
@@ -1,8 +1,10 @@
+import { SettingsKey } from "@shared/types/settings";
+
 export enum WarningTypeEnums {
-  SValency = "Subject Valency",
-  A1Valency = "Actant1 Valency",
-  A2Valency = "Actant2 Valency",
-  NoTerritory = "No Territory",
+  SValency = "SValency",
+  A1Valency = "A1Valency",
+  A2Valency = "A2Valency",
+  NoTerritory = "NoTerritory",
 
   NA = "NA", // "No Action defined",
   MA = "MA", // "Missing actant: at least one actant of a matching type should be used",
@@ -30,3 +32,204 @@ export enum WarningTypeEnums {
   TVER = "TVER", // Reference missing
   TVERE = "TVERE", // Reference wrong entity
 }
+
+export const ValidationKeys = Object.keys(WarningTypeEnums).reduce(
+  (acc, key) => {
+    const validationKey = `validation_${key}` as ValidationKey;
+    acc[validationKey] = validationKey;
+    return acc;
+  },
+  {} as Record<`validation_${keyof typeof WarningTypeEnums}`, string>
+);
+
+export type ValidationKey = keyof typeof ValidationKeys;
+
+type IWarningWithDescription = {
+  [key in ValidationKey]: {
+    label: string;
+    description: string;
+    editAllowed: boolean;
+    section?: "valency" | "entity" | "territory";
+  };
+};
+
+export const globalValidationsDict: IWarningWithDescription = {
+  validation_SValency: {
+    label: "Subject Valency",
+    description: "",
+    editAllowed: true,
+  },
+  validation_A1Valency: {
+    label: "Actant1 Valency",
+    description: "",
+    editAllowed: true,
+  },
+  validation_A2Valency: {
+    label: "Actant2 Valency",
+    description: "",
+    editAllowed: true,
+  },
+  validation_NoTerritory: {
+    label: "No Territory",
+    description: "",
+    editAllowed: true,
+  },
+  // Valency validations
+  validation_NA: {
+    label: "No Action defined",
+    description: "",
+    editAllowed: true,
+    section: "valency",
+  },
+  validation_MA: {
+    label: "Missing actant",
+    description: "At least one actant of a matching type should be used",
+    editAllowed: true,
+    section: "valency",
+  },
+  validation_WA: {
+    label: "Actant not matches the Action",
+    description: "Actant’s entity type does not match the Action",
+    editAllowed: true,
+    section: "valency",
+  },
+  validation_ANA: {
+    label: "Position allows no actant",
+    description: "",
+    editAllowed: true,
+    section: "valency",
+  },
+  validation_WAC: {
+    label: "Action valencies not matching",
+    description: "",
+    editAllowed: true,
+    section: "valency",
+  },
+  validation_AVU: {
+    label: "Action valencies not defined",
+    description: "",
+    editAllowed: true,
+    section: "valency",
+  },
+
+  // ???
+  validation_IELVL: {
+    label: "Inconsistent Epistemic levels for the Property",
+    description: "",
+    editAllowed: false,
+    section: "entity",
+  },
+  // Entity validations
+  validation_SCLM: {
+    label: "Superclass missing",
+    description:
+      "There is at least one relation of type SCL which has the Entity at index 0",
+    editAllowed: true,
+    section: "entity",
+  },
+  validation_ISYNC: {
+    label: "Inconsistent superclasses in the SYN cloud",
+    description:
+      "All Concepts in the SYN cloud (SYN Relation) have exactly the same SCL Relations.",
+    editAllowed: false,
+    section: "entity",
+  },
+  validation_MVAL: {
+    label: "Missing at least one entity-type valency",
+    description:
+      "Every A needs to have at least one of the S slots (subject, actant1, actant2) entity type filled (the warning is active when all three are undefined) ",
+    editAllowed: false,
+    section: "entity",
+  },
+  validation_AVAL: {
+    label: "Asymmetrical valency",
+    description:
+      "Checking symmetry between the three valency types: unless the only value in entity-type valency for the given slot is 'empty', then (a) morphosyntactic valency must be filled in (at least one character), (b) semantic valency of that slot (SUS, A1S, A2S - depending on the slot) must be set. Also the other way around: if there is non-empty morphosyntactic valency, then the other two types of valency (semantic valency and entity-type valency) must be filled in for the given slot. I.e., simply put: if any of the valencies is set and the only value is not 'empty' (this last condition applies of course to entity type valency only), the other two must be filled in also for that slot. Works also the other way: if the slot has entity-type valency empty only, then the grammatical and semantic valency must be empty.",
+    editAllowed: false,
+    section: "entity",
+  },
+  validation_VETM: {
+    label: "Entity type not filled in for all valencies", // Empty valency for Action
+    description:
+      "User should explicitly use the 'empty' option, the list of allowed entity types should not be empty (length 0)",
+    editAllowed: false,
+    section: "entity",
+  },
+  validation_MAEE: {
+    label: "Missing action/event equivalent",
+    description: "To be valid, every A needs to have an AEE relation.",
+    editAllowed: true,
+    section: "entity",
+  },
+  validation_PSM: {
+    label: "Missing part of speech attribute",
+    description:
+      "Value empty is assigned to the Part of Speech attribute of the Concept Entity",
+    editAllowed: false,
+    section: "entity",
+  },
+  validation_LM: {
+    label: "Missing label language attribute",
+    description: "Language attribute is empty.",
+    editAllowed: false,
+    section: "entity",
+  },
+  // T-based validations
+  validation_TVEP: {
+    label: "Entity should have a property",
+    description: "",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVEPT: {
+    label: "Entity is missing a required property type", // wrong type
+    description: "",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVEPV: {
+    label: "Entity has a wrong property value",
+    description:
+      "Entity has a Prop with a correct type (according to the protocol), but the Prop value is either missing or wrong",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVEC: {
+    label: "Entity should have a classification",
+    description: "Any classification should be assigned to E",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVECE: {
+    label: "Entity is  not classified to valid entity",
+    description: "Entity does have a Classification but the entity is invalid",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVER: {
+    label: "Entity should have a reference",
+    description: "Any reference should be assigned to E",
+    editAllowed: true,
+    section: "territory",
+  },
+  validation_TVERE: {
+    label: "Entity is not referenced to a valid entity",
+    description: "Entity does have a Reference but the R entity is invalid",
+    editAllowed: true,
+    section: "territory",
+  },
+};
+
+export type WarningKey = keyof typeof WarningTypeEnums;
+
+export const valencyKeys = Object.keys(globalValidationsDict).filter(
+  (key) => globalValidationsDict[key as ValidationKey].section === "valency"
+) as ValidationKey[];
+
+export const entityKeys = Object.keys(globalValidationsDict).filter(
+  (key) => globalValidationsDict[key as ValidationKey].section === "entity"
+) as ValidationKey[];
+
+export const territoryKeys = Object.keys(globalValidationsDict).filter(
+  (key) => globalValidationsDict[key as ValidationKey].section === "territory"
+) as ValidationKey[];
diff --git a/packages/shared/types/document.ts b/packages/shared/types/document.ts
index f0ccb3a58..cbafbf152 100644
--- a/packages/shared/types/document.ts
+++ b/packages/shared/types/document.ts
@@ -1,19 +1,18 @@
 import { EntityEnums } from "@shared/enums";
 
 // just meta information + title...without content
-export interface IDocumentMeta {
+export type IDocumentMeta = Omit<IDocument, "content">;
+
+// added content for completion
+export interface IDocument {
   id: string;
   title: string;
+  content: string;
   entityIds: string[];
   createdAt?: Date;
   updatedAt?: Date;
 }
 
-// added content for completion
-export interface IDocument extends IDocumentMeta {
-  content: string;
-}
-
 // lookup -> getAll
 export interface IResponseDocument {
   id: string;
diff --git a/packages/shared/types/index.ts b/packages/shared/types/index.ts
index 10a70f6c8..627c14e04 100644
--- a/packages/shared/types/index.ts
+++ b/packages/shared/types/index.ts
@@ -1,8 +1,8 @@
-import { IWarning, IWarningPosition } from "./warning";
 import { IAudit } from "./audit";
 import { ILabel } from "./label";
 import { IReference } from "./reference";
 import { IValue, IValueData } from "./value";
+import { IWarning, IWarningPosition } from "./warning";
 
 import { IAction, IActionData } from "./action";
 import { IBeing, IBeingData } from "./being";
@@ -52,6 +52,13 @@ import {
 } from "./response-tree";
 import { IResponseStoredTerritory, IResponseUser } from "./response-user";
 
+import {
+  IDocument,
+  IDocumentMeta,
+  IResponseDocument,
+  IResponseDocumentDetail,
+} from "./document";
+import { IRequestStats } from "./request-stats";
 import { IResponseEntity } from "./response-entity";
 import { IResponseStats } from "./response-stats";
 import {
@@ -61,12 +68,6 @@ import {
   IUserOptions,
   IUserRight,
 } from "./user";
-import {
-  IDocument,
-  IResponseDocument,
-  IResponseDocumentDetail,
-  IDocumentMeta,
-} from "./document";
 
 import {
   IRequestPasswordReset,
@@ -76,73 +77,74 @@ import {
 import { IRequestActivationData } from "./request-activation";
 
 export type {
-  IAudit,
-  IEntity,
+  ClassificationOrder,
+  EntityOrder,
+  EntityTooltip,
   IAction,
   IActionData,
-  ITerritory,
-  ITerritoryData,
-  IParentTerritory,
-  IStatement,
-  IStatementData,
-  IStatementAction,
-  IStatementActant,
-  IStatementDataTerritory,
-  IResource,
-  IResourceData,
-  IPerson,
-  IPersonData,
+  IAudit,
   IBeing,
   IBeingData,
-  IGroup,
-  IGroupData,
-  IObject,
-  IObjectData,
+  IBookmarkFolder,
   IConcept,
-  ILocation,
-  ILocationData,
-  IValue,
-  IValueData,
+  IdentificationOrder,
+  IDocument,
+  IDocumentMeta,
+  IEntity,
   IEvent,
   IEventData,
+  IGroup,
+  IGroupData,
   ILabel,
+  ILocation,
+  ILocationData,
+  IObject,
+  IObjectData,
+  IParentTerritory,
+  IPerson,
+  IPersonData,
   IProp,
   IPropSpec,
   IReference,
-  IUser,
-  IUserOptions,
-  IUserRight,
-  IBookmarkFolder,
-  IStoredTerritory,
+  IRequestActivationData,
+  IRequestPasswordReset,
+  IRequestPasswordResetData,
+  IRequestStats,
+  IResource,
+  IResourceData,
   IResponseAudit,
-  IResponseEntity,
-  IResponseDetail,
-  IResponseUsedInMetaProp,
-  IResponseUsedInStatement,
   IResponseBookmarkFolder,
+  IResponseDetail,
+  IResponseDocument,
+  IResponseDocumentDetail,
+  IResponseEntity,
+  IResponseGeneric,
+  IResponsePermission,
   IResponseStatement,
+  IResponseStats,
+  IResponseStoredTerritory,
   IResponseTerritory,
   IResponseTree,
   IResponseTreeTerritoryComponent,
+  IResponseUsedInMetaProp,
+  IResponseUsedInStatement,
   IResponseUser,
-  IResponseStoredTerritory,
-  IResponseGeneric,
-  IResponsePermission,
-  IResponseStats,
-  EntityTooltip,
-  EntityOrder,
-  PropOrder,
+  IStatement,
+  IStatementActant,
+  IStatementAction,
+  IStatementData,
+  IStatementDataTerritory,
+  IStoredTerritory,
+  ITerritory,
+  ITerritoryData,
+  IUser,
+  IUserOptions,
+  IUserRight,
+  IValue,
+  IValueData,
   IWarning,
   IWarningPosition,
-  ClassificationOrder,
-  IdentificationOrder,
-  IDocument,
-  IResponseDocument,
-  IResponseDocumentDetail,
-  IDocumentMeta,
-  IRequestPasswordReset,
-  IRequestPasswordResetData,
-  IRequestActivationData,
+  PropOrder,
 };
 
-export { RequestSearch, RequestPermissionUpdate, Relation };
+export { Relation, RequestPermissionUpdate, RequestSearch };
diff --git a/packages/shared/types/prop.ts b/packages/shared/types/prop.ts
index b1110076e..2d835d99f 100644
--- a/packages/shared/types/prop.ts
+++ b/packages/shared/types/prop.ts
@@ -17,6 +17,11 @@ export interface IProp {
   value: IPropSpec;
 }
 
+export enum PropSpecKind {
+  TYPE = "type",
+  VALUE = "value",
+}
+
 export interface IPropSpec {
   entityId: string;
   elvl: EntityEnums.Elvl;
diff --git a/packages/shared/types/request-stats.ts b/packages/shared/types/request-stats.ts
index 734063039..9b236d0a5 100644
--- a/packages/shared/types/request-stats.ts
+++ b/packages/shared/types/request-stats.ts
@@ -10,7 +10,8 @@ export interface IRequestStats {
   aggregateBy: Aggregation;
   filter: {
     userIds: string[] | "all";
-    activities: {
+    editActivities: {
+      // relevant only for the edit function
       entities: boolean; // handling entities
       relationsMeta: boolean; // relations inside entities
       relationsStatement: boolean; // in-statment relations
@@ -20,6 +21,6 @@ export interface IRequestStats {
       tags: boolean; // tags for statements and entities
     };
     entityTypes: EntityEnums.Class[] | "all"; // what entities are involved
-    relationTypes: RelationEnums.Type[] | "all"; // what relations are involved
+    relationTypes: RelationEnums.Type[] | "all"; // what relations are involved - valid for edit
   };
 }
diff --git a/packages/shared/types/response-detail.ts b/packages/shared/types/response-detail.ts
index 10ccd3449..cbfe44c8e 100644
--- a/packages/shared/types/response-detail.ts
+++ b/packages/shared/types/response-detail.ts
@@ -2,7 +2,7 @@
  * Very extensive object showing all the details about one actant
  */
 
-import { IEntity, Relation, IResponseEntity, IStatement, IWarning } from ".";
+import { IEntity, IResponseEntity, IStatement, IWarning, Relation } from ".";
 import { EntityEnums } from "../enums";
 import { IDocumentMeta } from "./document";
 import {
@@ -16,17 +16,27 @@ export interface IResponseDetail extends IResponseEntity {
   usedInStatementProps: IResponseUsedInStatementProps[]; // all statements, where the detail id is used in props
   usedInMetaProps: IResponseUsedInMetaProp[]; // all entities, where the detail id is used in props (entity.props[])
 
+  usedInDocuments: IResponseUsedInDocument[]; // all documents, where the detail id is used
+
   usedInStatementIdentifications: IResponseUsedInStatementIdentification[]; // statement.data.actants[].identifications + from usedInStatements field if actant.entityId = detailId
   usedInStatementClassifications: IResponseUsedInStatementClassification[]; // statement.data.actants[].classifications + from usedInStatements field if actant.entityId = detailId
 
   usedAsTemplate?: string[];
-  usedInDocuments: IDocumentMeta[];
 
   relations: Relation.IUsedRelations;
 
   warnings: IWarning[];
 }
 
+// model is reapeated for each anchor in each document,
+// so e.g., when the entity is used in 2 documents, and in one document it is used in 3 anchors, in the second is used in 1 anchor, model will be repeated 4 times
+export interface IResponseUsedInDocument {
+  document: IDocumentMeta;
+  anchorText: string; // content of the anchor
+  resourceId: string; // resource linked to the document
+  parentTerritoryId: string; // id of the closest territory anchor in the document, "" if no territory is found
+}
+
 export interface IResponseUsedInStatement<PositionEnum> {
   statement: IStatement;
   position: PositionEnum;
diff --git a/packages/shared/types/settings.ts b/packages/shared/types/settings.ts
new file mode 100644
index 000000000..435fa7c8f
--- /dev/null
+++ b/packages/shared/types/settings.ts
@@ -0,0 +1,14 @@
+import { ValidationKey } from "@shared/enums/warning";
+
+export interface ISetting {
+  id: SettingsKey;
+  value: unknown;
+  public: boolean;
+}
+
+export interface ISettingGroup {
+  id: string;
+  settings: ISetting[];
+}
+
+export type SettingsKey = string;
diff --git a/packages/shared/types/stats.ts b/packages/shared/types/stats.ts
index 614dc33b6..fdd524100 100644
--- a/packages/shared/types/stats.ts
+++ b/packages/shared/types/stats.ts
@@ -14,5 +14,5 @@ export enum EventType {
 export enum Aggregation {
   USER = "user",
   ENTITY_TYPE = "entityType",
-  ACTIVITY_TYPE = "activityType",
+  ACTIVITY_TYPE = "activityType", // in case of edit activity type
 }