diff --git a/src/components/app.jsx b/src/components/app.jsx
index 4ed4b0617e..5a314cceea 100644
--- a/src/components/app.jsx
+++ b/src/components/app.jsx
@@ -73,7 +73,7 @@ import useStudyNavigationSync from 'hooks/use-study-navigation-sync';
 import { useOptionalLoadingParameters } from '../hooks/use-optional-loading-parameters';
 import { SortWay } from '../types/custom-aggrid-types.ts';
 import { useBaseVoltages } from '../hooks/use-base-voltages.ts';
-import { useGlobalFilterOptions } from './results/common/global-filter/use-global-filter-options.ts';
+import { useGlobalFilterOptions } from './results/common/global-filter/hooks/use-global-filter-options.ts';
 import { updateComputationColumnFilters, updateComputationGlobalFilters } from './results/common/utils.ts';
 import { isEditingGlobalFilter } from '../utils/editing-global-filter-sync.ts';
 import { cleanupStaleStudyData } from '../redux/session-storage/local-storage';
diff --git a/src/components/results/common/global-filter/adapter/global-filter-app-data.ts b/src/components/results/common/global-filter/adapter/global-filter-app-data.ts
new file mode 100644
index 0000000000..7215f2aefe
--- /dev/null
+++ b/src/components/results/common/global-filter/adapter/global-filter-app-data.ts
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { fetchStudyMetadata } from '@gridsuite/commons-ui';
+
+export async function fetchSubstationPropertiesGlobalFilters(): Promise<{
+    substationPropertiesGlobalFilters?: Map<string, string[]>;
+}> {
+    const { substationPropertiesGlobalFilters } = await fetchStudyMetadata();
+    const definedSubstationPropertiesGlobalFilters: Map<string, string[]> = substationPropertiesGlobalFilters
+        ? new Map(Object.entries(substationPropertiesGlobalFilters))
+        : new Map<string, string[]>();
+    return {
+        substationPropertiesGlobalFilters: definedSubstationPropertiesGlobalFilters,
+    };
+}
diff --git a/src/components/results/common/global-filter/adapter/global-filter-provider.tsx b/src/components/results/common/global-filter/adapter/global-filter-provider.tsx
new file mode 100644
index 0000000000..9592b2054c
--- /dev/null
+++ b/src/components/results/common/global-filter/adapter/global-filter-provider.tsx
@@ -0,0 +1,215 @@
+/**
+ * Copyright (c) 2025, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { PropsWithChildren, useCallback, useEffect, useMemo, useState } from 'react';
+import { GlobalFilter, RecentGlobalFilter } from '../global-filter.type';
+import { FilterType, isCriteriaFilter } from '../../utils';
+import {
+    ElementAttributes,
+    ElementType,
+    EquipmentType,
+    fetchDirectoryElementPath,
+    fetchElementsInfos,
+    snackWithFallback,
+    useSnackMessage,
+} from '@gridsuite/commons-ui';
+import { computeFullPath } from '../../../../../utils/compute-title';
+import {
+    addToGlobalFilterOptions,
+    addToSelectedGlobalFilters,
+    clearSelectedGlobalFilters as clearSelectedGlobalFiltersAction,
+    markNotFoundGlobalFiltersAsDeleted,
+    removeFromGlobalFilterOptions,
+    removeFromSelectedGlobalFilters,
+} from '../../../../../redux/actions';
+import { useDispatch, useSelector } from 'react-redux';
+import { AppDispatch } from '../../../../../redux/store';
+import { HttpStatusCode } from '../../../../../utils/http-status-code';
+import { TableType } from '../../../../../types/custom-aggrid-types';
+import { AppState } from '../../../../../redux/reducer.type';
+import GlobalFilterContextProvider from '../context/global-filter-context-provider';
+import { fetchSubstationPropertiesGlobalFilters } from './global-filter-app-data';
+import { useLocalizedCountries } from '../../../../utils/localized-countries-hook';
+import type { UUID } from 'node:crypto';
+
+const EMPTY_ARRAY: RecentGlobalFilter[] = [];
+
+type FilterUpdateResult = { kind: 'updated' | 'notFound'; filter: GlobalFilter } | { kind: 'unchanged' };
+
+type GlobalFilterProviderProps = PropsWithChildren<{
+    filterCategories: FilterType[];
+    genericFiltersStrictMode: boolean;
+    filterableEquipmentTypes: string[];
+    tableType: TableType;
+    tableUuid: string;
+}>;
+
+export default function GlobalFilterProvider({
+    children,
+    filterCategories,
+    genericFiltersStrictMode = false,
+    filterableEquipmentTypes = [],
+    tableType,
+    tableUuid,
+}: Readonly<GlobalFilterProviderProps>) {
+    const dispatch = useDispatch<AppDispatch>();
+    const { snackError } = useSnackMessage();
+    const { translate: translateCountryCode } = useLocalizedCountries();
+    const [substationPropertiesGlobalFilters, setSubstationPropertiesGlobalFilters] = useState<Map<string, string[]>>();
+
+    const globalFilterOptions = useSelector((state: AppState) => state.globalFilterOptions);
+
+    const selectedFilterIds = useSelector((state: AppState) => state.tableFilters.globalFilters[tableUuid]?.selected);
+
+    const recentGlobalFilters = useSelector(
+        (state: AppState) => state.tableFilters.globalFilters[tableUuid]?.recents ?? EMPTY_ARRAY
+    );
+
+    const selectedGlobalFilters = useMemo(
+        () =>
+            selectedFilterIds
+                ? selectedFilterIds
+                      .map((id) => globalFilterOptions.find((opt) => opt.id === id))
+                      .filter((filter): filter is GlobalFilter => filter !== undefined)
+                : [],
+        [selectedFilterIds, globalFilterOptions]
+    );
+
+    useEffect(() => {
+        fetchSubstationPropertiesGlobalFilters().then(({ substationPropertiesGlobalFilters }) => {
+            setSubstationPropertiesGlobalFilters(substationPropertiesGlobalFilters);
+        });
+    }, []);
+
+    const updateGenericFilter = useCallback(
+        async (genericFilter: GlobalFilter): Promise<FilterUpdateResult> => {
+            try {
+                if (!genericFilter.uuid) {
+                    return { kind: 'unchanged' };
+                }
+                const response: ElementAttributes[] = await fetchDirectoryElementPath(genericFilter.uuid);
+                const parentDirectoriesNames = response.map((parent) => parent.elementName);
+                const label =
+                    response.find((parent) => parent.type === ElementType.FILTER)?.elementName ?? genericFilter.label;
+                const path = computeFullPath(parentDirectoriesNames);
+                if (path !== genericFilter.path || label !== genericFilter.label) {
+                    return { kind: 'updated', filter: { ...genericFilter, path, label } };
+                }
+                return { kind: 'unchanged' };
+            } catch (responseError) {
+                const error = responseError as Error & { status: number };
+                if (error.status === HttpStatusCode.NOT_FOUND) {
+                    return { kind: 'notFound', filter: genericFilter };
+                }
+                snackWithFallback(snackError, error, {
+                    headerId: 'ComputationFilterResultsError',
+                });
+                return { kind: 'unchanged' };
+            }
+        },
+        [snackError]
+    );
+
+    // Check the selected global filters and mark them as deleted if they no longer exist.
+    useEffect(() => {
+        const checkSelectedFilters = async () => {
+            const genericFilters: GlobalFilter[] = selectedGlobalFilters.filter(
+                (globalFilter) => isCriteriaFilter(globalFilter) && !globalFilter.deleted
+            );
+            const results = await Promise.all(genericFilters.map(updateGenericFilter));
+            const updatedFilters: GlobalFilter[] = [];
+            const notFoundFilters: GlobalFilter[] = [];
+            for (const result of results) {
+                if (result.kind === 'updated') updatedFilters.push(result.filter);
+                else if (result.kind === 'notFound') notFoundFilters.push(result.filter);
+            }
+            if (updatedFilters.length) {
+                dispatch(addToGlobalFilterOptions(updatedFilters));
+            }
+            if (notFoundFilters.length) {
+                dispatch(markNotFoundGlobalFiltersAsDeleted(notFoundFilters, tableUuid, tableType));
+            }
+        };
+
+        checkSelectedFilters().catch((error) => console.error(error));
+    }, [dispatch, selectedGlobalFilters, tableType, tableUuid, updateGenericFilter]);
+
+    const selectGlobalFilter = useCallback(
+        (id: string) => {
+            dispatch(addToSelectedGlobalFilters(tableType, tableUuid, [id]));
+        },
+        [dispatch, tableType, tableUuid]
+    );
+
+    const unselectGlobalFilters = useCallback(
+        (ids: string[]) => {
+            dispatch(removeFromSelectedGlobalFilters(tableType, tableUuid, ids));
+        },
+        [dispatch, tableType, tableUuid]
+    );
+
+    const clearSelectedGlobalFilters = useCallback(() => {
+        dispatch(clearSelectedGlobalFiltersAction(tableType, tableUuid));
+    }, [dispatch, tableType, tableUuid]);
+
+    const removeGlobalFilterOption = useCallback(
+        (id: string) => {
+            dispatch(removeFromGlobalFilterOptions(id));
+        },
+        [dispatch]
+    );
+
+    const addFiltersToGlobalFiltersOptions = useCallback(
+        async (elementIds: UUID[]) => {
+            const elements: ElementAttributes[] = await fetchElementsInfos(elementIds);
+            const newlySelectedFilters: GlobalFilter[] = [];
+            elements.forEach((element: ElementAttributes) => {
+                // ignore already selected filters and non-generic filters :
+                if (!selectedGlobalFilters.find((filter) => filter.uuid && filter.uuid === element.elementUuid)) {
+                    // add the others
+                    const substationOrVoltageLevel =
+                        element.specificMetadata?.equipmentType === EquipmentType.SUBSTATION ||
+                        element.specificMetadata?.equipmentType === EquipmentType.VOLTAGE_LEVEL;
+                    newlySelectedFilters.push({
+                        id: element.elementUuid,
+                        uuid: element.elementUuid,
+                        equipmentType: element.specificMetadata?.equipmentType,
+                        label: element.elementName,
+                        filterType: substationOrVoltageLevel ? FilterType.SUBSTATION_OR_VL : FilterType.GENERIC_FILTER,
+                        filterTypeFromMetadata: element.specificMetadata?.type,
+                    });
+                }
+            });
+
+            dispatch(addToGlobalFilterOptions(newlySelectedFilters));
+            newlySelectedFilters.forEach((filter) =>
+                dispatch(addToSelectedGlobalFilters(tableType, tableUuid, [filter.id]))
+            );
+        },
+        [dispatch, selectedGlobalFilters, tableType, tableUuid]
+    );
+
+    return (
+        <GlobalFilterContextProvider
+            globalFilterOptions={globalFilterOptions}
+            selectedGlobalFilters={selectedGlobalFilters}
+            recentGlobalFilters={recentGlobalFilters}
+            substationPropertiesGlobalFilters={substationPropertiesGlobalFilters}
+            filterCategories={filterCategories}
+            genericFiltersStrictMode={genericFiltersStrictMode}
+            filterableEquipmentTypes={filterableEquipmentTypes}
+            translateCountryCode={translateCountryCode}
+            selectGlobalFilter={selectGlobalFilter}
+            unselectGlobalFilters={unselectGlobalFilters}
+            clearSelectedGlobalFilters={clearSelectedGlobalFilters}
+            removeGlobalFilterOption={removeGlobalFilterOption}
+            addFiltersToGlobalFiltersOptions={addFiltersToGlobalFiltersOptions}
+        >
+            {children}
+        </GlobalFilterContextProvider>
+    );
+}
diff --git a/src/components/results/common/global-filter/context/global-filter-context-provider.tsx b/src/components/results/common/global-filter/context/global-filter-context-provider.tsx
new file mode 100644
index 0000000000..a0a1240717
--- /dev/null
+++ b/src/components/results/common/global-filter/context/global-filter-context-provider.tsx
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { useMemo } from 'react';
+import { GlobalFilterContext } from './global-filter-context';
+import { GlobalFilterContextProviderProps, GlobalFilterContextValue } from './global-filter-context.type';
+
+export default function GlobalFilterContextProvider({
+    children,
+    globalFilterOptions,
+    selectedGlobalFilters,
+    recentGlobalFilters,
+    substationPropertiesGlobalFilters,
+    filterCategories,
+    genericFiltersStrictMode,
+    filterableEquipmentTypes,
+    translateCountryCode,
+    selectGlobalFilter,
+    unselectGlobalFilters,
+    clearSelectedGlobalFilters,
+    removeGlobalFilterOption,
+    addFiltersToGlobalFiltersOptions,
+}: Readonly<GlobalFilterContextProviderProps>) {
+    const value = useMemo<GlobalFilterContextValue>(
+        () => ({
+            globalFilterOptions,
+            selectedGlobalFilters,
+            recentGlobalFilters,
+            substationPropertiesGlobalFilters,
+            filterCategories,
+            genericFiltersStrictMode,
+            filterableEquipmentTypes,
+            translateCountryCode,
+            selectGlobalFilter,
+            unselectGlobalFilters,
+            clearSelectedGlobalFilters,
+            removeGlobalFilterOption,
+            addFiltersToGlobalFiltersOptions,
+        }),
+        [
+            globalFilterOptions,
+            selectedGlobalFilters,
+            recentGlobalFilters,
+            substationPropertiesGlobalFilters,
+            filterCategories,
+            genericFiltersStrictMode,
+            filterableEquipmentTypes,
+            translateCountryCode,
+            selectGlobalFilter,
+            unselectGlobalFilters,
+            clearSelectedGlobalFilters,
+            removeGlobalFilterOption,
+            addFiltersToGlobalFiltersOptions,
+        ]
+    );
+
+    return <GlobalFilterContext.Provider value={value}>{children}</GlobalFilterContext.Provider>;
+}
diff --git a/src/components/results/common/global-filter/context/global-filter-context.ts b/src/components/results/common/global-filter/context/global-filter-context.ts
new file mode 100644
index 0000000000..c720ac5924
--- /dev/null
+++ b/src/components/results/common/global-filter/context/global-filter-context.ts
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { createContext, useContext } from 'react';
+import { GlobalFilterContextValue } from './global-filter-context.type';
+
+export const GlobalFilterContext = createContext<GlobalFilterContextValue | null>(null);
+
+export function useGlobalFilterContext() {
+    const context = useContext(GlobalFilterContext);
+    if (!context) {
+        throw new Error('useGlobalFilterContext must be used inside GlobalFilterProvider');
+    }
+    return context;
+}
diff --git a/src/components/results/common/global-filter/context/global-filter-context.type.ts b/src/components/results/common/global-filter/context/global-filter-context.type.ts
new file mode 100644
index 0000000000..0b89e62cc3
--- /dev/null
+++ b/src/components/results/common/global-filter/context/global-filter-context.type.ts
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { PropsWithChildren } from 'react';
+import { GlobalFilter, RecentGlobalFilter } from '../global-filter.type';
+import type { UUID } from 'node:crypto';
+
+export type GlobalFilterContextValue = {
+    globalFilterOptions: GlobalFilter[];
+    selectedGlobalFilters: GlobalFilter[];
+    recentGlobalFilters: RecentGlobalFilter[];
+    substationPropertiesGlobalFilters?: Map<string, string[]>;
+    filterCategories: string[];
+    genericFiltersStrictMode: boolean;
+    filterableEquipmentTypes: string[];
+    translateCountryCode: (countryCode: string) => string;
+    selectGlobalFilter: (id: string) => void;
+    unselectGlobalFilters: (ids: string[]) => void;
+    clearSelectedGlobalFilters: () => void;
+    removeGlobalFilterOption: (id: string) => void;
+    addFiltersToGlobalFiltersOptions: (elementIds: UUID[]) => Promise<void>;
+};
+
+export type GlobalFilterContextProviderProps = PropsWithChildren<GlobalFilterContextValue>;
diff --git a/src/components/results/common/global-filter/global-filter-context.ts b/src/components/results/common/global-filter/global-filter-context.ts
deleted file mode 100644
index 00c76facb2..0000000000
--- a/src/components/results/common/global-filter/global-filter-context.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Copyright (c) 2025, RTE (http://www.rte-france.com)
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-import { createContext } from 'react';
-import { GlobalFilter } from './global-filter-types';
-import { TableType } from '../../../../types/custom-aggrid-types';
-import type { RecentGlobalFilter } from './global-filter-types';
-
-export const GlobalFilterContext = createContext<{
-    // manage internal states
-    openedDropdown: boolean;
-    setOpenedDropdown: (open: boolean) => void;
-    directoryItemSelectorOpen: boolean;
-    setDirectoryItemSelectorOpen: (open: boolean) => void;
-    filterGroupSelected?: string;
-    setFilterGroupSelected: (selectedFilterGroup: string) => void;
-    globalFilterOptions: GlobalFilter[];
-    selectedGlobalFilters: GlobalFilter[];
-    recentGlobalFilters: RecentGlobalFilter[];
-    filterCategories: string[];
-    genericFiltersStrictMode: boolean;
-    filterableEquipmentTypes: string[];
-    tableType: TableType;
-    tableUuid: string;
-}>({
-    openedDropdown: false,
-    setOpenedDropdown: () => {},
-    directoryItemSelectorOpen: false,
-    setDirectoryItemSelectorOpen: () => {},
-    filterGroupSelected: undefined,
-    setFilterGroupSelected: () => {},
-    globalFilterOptions: [],
-    selectedGlobalFilters: [],
-    recentGlobalFilters: [],
-    filterCategories: [],
-    genericFiltersStrictMode: false,
-    filterableEquipmentTypes: [],
-    tableType: TableType.Loadflow,
-    tableUuid: TableType.Loadflow,
-});
diff --git a/src/components/results/common/global-filter/global-filter-provider.tsx b/src/components/results/common/global-filter/global-filter-provider.tsx
deleted file mode 100644
index bd1db01fe9..0000000000
--- a/src/components/results/common/global-filter/global-filter-provider.tsx
+++ /dev/null
@@ -1,155 +0,0 @@
-/**
- * Copyright (c) 2025, RTE (http://www.rte-france.com)
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-import { PropsWithChildren, useCallback, useEffect, useMemo, useState } from 'react';
-import { GlobalFilter, RecentGlobalFilter } from './global-filter-types';
-import { FilterType, isCriteriaFilter } from '../utils';
-import {
-    ElementAttributes,
-    ElementType,
-    fetchDirectoryElementPath,
-    snackWithFallback,
-    useSnackMessage,
-} from '@gridsuite/commons-ui';
-import { computeFullPath } from '../../../../utils/compute-title';
-import { addToGlobalFilterOptions, markNotFoundGlobalFiltersAsDeleted } from '../../../../redux/actions';
-import { useDispatch, useSelector } from 'react-redux';
-import { AppDispatch } from '../../../../redux/store';
-import { GlobalFilterContext } from './global-filter-context';
-import { HttpStatusCode } from '../../../../utils/http-status-code';
-import { TableType } from '../../../../types/custom-aggrid-types';
-import { AppState } from '../../../../redux/reducer.type';
-
-const EMPTY_ARRAY: RecentGlobalFilter[] = [];
-type FilterUpdateResult = { kind: 'updated' | 'notFound'; filter: GlobalFilter } | { kind: 'unchanged' };
-export default function GlobalFilterProvider({
-    children,
-    filterCategories,
-    genericFiltersStrictMode = false,
-    filterableEquipmentTypes = [],
-    tableType,
-    tableUuid,
-}: PropsWithChildren & {
-    filterCategories: FilterType[];
-    genericFiltersStrictMode: boolean;
-    filterableEquipmentTypes: string[];
-    tableType: TableType;
-    tableUuid: string;
-}) {
-    const dispatch = useDispatch<AppDispatch>();
-    const { snackError } = useSnackMessage();
-
-    const globalFilterOptions = useSelector((state: AppState) => state.globalFilterOptions);
-
-    const selectedFilterIds = useSelector((state: AppState) => state.tableFilters.globalFilters[tableUuid]?.selected);
-
-    const recentGlobalFilters = useSelector(
-        (state: AppState) => state.tableFilters.globalFilters[tableUuid]?.recents ?? EMPTY_ARRAY
-    );
-
-    const selectedGlobalFilters = useMemo(
-        () =>
-            selectedFilterIds
-                ? selectedFilterIds
-                      .map((id) => globalFilterOptions.find((opt) => opt.id === id))
-                      .filter((f) => f !== undefined)
-                : [],
-        [selectedFilterIds, globalFilterOptions]
-    );
-
-    const [openedDropdown, setOpenedDropdown] = useState(false);
-    const [directoryItemSelectorOpen, setDirectoryItemSelectorOpen] = useState(false);
-    // maybe a filter type or a recent filter or whatever category
-    const [filterGroupSelected, setFilterGroupSelected] = useState<string>(FilterType.VOLTAGE_LEVEL);
-
-    const updateGenericFilter = useCallback(
-        async (genericFilter: GlobalFilter): Promise<FilterUpdateResult> => {
-            try {
-                if (!genericFilter.uuid) {
-                    return { kind: 'unchanged' };
-                }
-                const response: ElementAttributes[] = await fetchDirectoryElementPath(genericFilter.uuid);
-                const parentDirectoriesNames = response.map((parent) => parent.elementName);
-                const label =
-                    response.find((parent) => parent.type === ElementType.FILTER)?.elementName ?? genericFilter.label;
-                const path = computeFullPath(parentDirectoriesNames);
-                if (path !== genericFilter.path || label !== genericFilter.label) {
-                    return { kind: 'updated', filter: { ...genericFilter, path, label } };
-                }
-                return { kind: 'unchanged' };
-            } catch (responseError) {
-                const error = responseError as Error & { status: number };
-                if (error.status === HttpStatusCode.NOT_FOUND) {
-                    return { kind: 'notFound', filter: genericFilter };
-                }
-                snackWithFallback(snackError, error, {
-                    headerId: 'ComputationFilterResultsError',
-                });
-                return { kind: 'unchanged' };
-            }
-        },
-        [snackError]
-    );
-
-    // Check the selected global filters and mark them as deleted if they no longer exist.
-    useEffect(() => {
-        const checkSelectedFilters = async () => {
-            const genericFilters: GlobalFilter[] = selectedGlobalFilters.filter(
-                (globalFilter) => isCriteriaFilter(globalFilter) && !globalFilter.deleted
-            );
-            const results = await Promise.all(genericFilters.map(updateGenericFilter));
-            const updatedFilters: GlobalFilter[] = [];
-            const notFoundFilters: GlobalFilter[] = [];
-            for (const result of results) {
-                if (result.kind === 'updated') updatedFilters.push(result.filter);
-                else if (result.kind === 'notFound') notFoundFilters.push(result.filter);
-            }
-            if (updatedFilters.length) {
-                dispatch(addToGlobalFilterOptions(updatedFilters));
-            }
-            if (notFoundFilters.length) {
-                dispatch(markNotFoundGlobalFiltersAsDeleted(notFoundFilters, tableUuid, tableType));
-            }
-        };
-
-        checkSelectedFilters().catch((error) => console.error(error));
-    }, [dispatch, selectedGlobalFilters, tableType, tableUuid, updateGenericFilter]);
-
-    const value = useMemo(
-        () => ({
-            openedDropdown,
-            setOpenedDropdown,
-            directoryItemSelectorOpen,
-            setDirectoryItemSelectorOpen,
-            filterGroupSelected,
-            setFilterGroupSelected,
-            globalFilterOptions,
-            selectedGlobalFilters,
-            recentGlobalFilters,
-            filterCategories,
-            genericFiltersStrictMode,
-            filterableEquipmentTypes,
-            tableType,
-            tableUuid,
-        }),
-        [
-            openedDropdown,
-            directoryItemSelectorOpen,
-            filterGroupSelected,
-            globalFilterOptions,
-            selectedGlobalFilters,
-            recentGlobalFilters,
-            filterCategories,
-            genericFiltersStrictMode,
-            filterableEquipmentTypes,
-            tableType,
-            tableUuid,
-        ]
-    );
-
-    return <GlobalFilterContext.Provider value={value}>{children}</GlobalFilterContext.Provider>;
-}
diff --git a/src/components/results/common/global-filter/global-filter-selector.tsx b/src/components/results/common/global-filter/global-filter-selector.tsx
index a35eab4c3a..9167430c4a 100644
--- a/src/components/results/common/global-filter/global-filter-selector.tsx
+++ b/src/components/results/common/global-filter/global-filter-selector.tsx
@@ -5,12 +5,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import GlobalFilterProvider from './global-filter-provider';
-import GlobalFilterAutocomplete from './global-filter-autocomplete';
+import GlobalFilterProvider from './adapter/global-filter-provider';
 import { FilterType } from '../utils';
 import { TableType } from '../../../../types/custom-aggrid-types';
 import type { UUID } from 'node:crypto';
 import { EquipmentType } from '@gridsuite/commons-ui';
+import GlobalFilter from './ui/global-filter';
 
 export type GlobalFilterSelectorProps = {
     filterCategories?: FilterType[];
@@ -35,7 +35,7 @@ export default function GlobalFilterSelector({
             tableType={tableType}
             tableUuid={tableUuid ?? tableType}
         >
-            <GlobalFilterAutocomplete />
+            <GlobalFilter />
         </GlobalFilterProvider>
     );
 }
diff --git a/src/components/results/common/global-filter/global-filter-styles.ts b/src/components/results/common/global-filter/global-filter.style.ts
similarity index 99%
rename from src/components/results/common/global-filter/global-filter-styles.ts
rename to src/components/results/common/global-filter/global-filter.style.ts
index a131afdb62..4ac99e4c3a 100644
--- a/src/components/results/common/global-filter/global-filter-styles.ts
+++ b/src/components/results/common/global-filter/global-filter.style.ts
@@ -9,7 +9,7 @@ import { cyan, lime } from '@mui/material/colors';
 import { FilterType } from '../utils';
 import { mergeSx, type MuiStyles } from '@gridsuite/commons-ui';
 import { Theme, SxProps } from '@mui/material';
-import { GlobalFilter } from './global-filter-types';
+import { GlobalFilter } from './global-filter.type';
 
 export const getResultsGlobalFiltersChipStyle = (element: GlobalFilter): SxProps<Theme> => {
     return mergeSx(
diff --git a/src/components/results/common/global-filter/global-filter-types.ts b/src/components/results/common/global-filter/global-filter.type.ts
similarity index 100%
rename from src/components/results/common/global-filter/global-filter-types.ts
rename to src/components/results/common/global-filter/global-filter.type.ts
diff --git a/src/components/results/common/global-filter/use-computation-global-filters.ts b/src/components/results/common/global-filter/hooks/use-computation-global-filters.ts
similarity index 86%
rename from src/components/results/common/global-filter/use-computation-global-filters.ts
rename to src/components/results/common/global-filter/hooks/use-computation-global-filters.ts
index a1e1383dd7..f5970cc809 100644
--- a/src/components/results/common/global-filter/use-computation-global-filters.ts
+++ b/src/components/results/common/global-filter/hooks/use-computation-global-filters.ts
@@ -4,12 +4,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
-import { TableType } from '../../../../types/custom-aggrid-types';
+import { TableType } from '../../../../../types/custom-aggrid-types';
 import { useDispatch, useSelector } from 'react-redux';
-import { AppState } from '../../../../redux/reducer.type';
+import { AppState } from '../../../../../redux/reducer.type';
 import { useEffect } from 'react';
 import { useSelectedGlobalFilters } from './use-selected-global-filters';
-import { updateComputationGlobalFilters } from '../utils';
+import { updateComputationGlobalFilters } from '../../utils';
 
 // Get the global filters for a given table from the server and store them in the Redux store
 export function useFetchComputationGlobalFilters(tableType: TableType) {
diff --git a/src/components/results/common/global-filter/use-global-filter-options.ts b/src/components/results/common/global-filter/hooks/use-global-filter-options.ts
similarity index 87%
rename from src/components/results/common/global-filter/use-global-filter-options.ts
rename to src/components/results/common/global-filter/hooks/use-global-filter-options.ts
index 511375e241..1022bafd09 100644
--- a/src/components/results/common/global-filter/use-global-filter-options.ts
+++ b/src/components/results/common/global-filter/hooks/use-global-filter-options.ts
@@ -6,17 +6,14 @@
  */
 import { snackWithFallback, useSnackMessage } from '@gridsuite/commons-ui';
 import { useEffect } from 'react';
-import { fetchAllCountries } from '../../../../services/study/network-map';
-import { FilterType } from '../utils';
-import {
-    addGlobalFilterId,
-    fetchSubstationPropertiesGlobalFilters,
-    GlobalFilterWithoutId,
-} from './global-filter-utils';
+import { fetchAllCountries } from '../../../../../services/study/network-map';
+import { FilterType } from '../../utils';
+import { addGlobalFilterId, GlobalFilterWithoutId } from '../utils/global-filter-utils';
+import { fetchSubstationPropertiesGlobalFilters } from '../adapter/global-filter-app-data';
 import { useDispatch, useSelector } from 'react-redux';
-import { AppState } from '../../../../redux/reducer.type';
-import { useBaseVoltages } from '../../../../hooks/use-base-voltages';
-import { addToGlobalFilterOptions } from '../../../../redux/actions';
+import { AppState } from '../../../../../redux/reducer.type';
+import { useBaseVoltages } from '../../../../../hooks/use-base-voltages';
+import { addToGlobalFilterOptions } from '../../../../../redux/actions';
 
 /**
  * Custom hook that manages global filter options for tables.
diff --git a/src/components/results/common/global-filter/use-global-filter-results.ts b/src/components/results/common/global-filter/hooks/use-global-filter-results.ts
similarity index 86%
rename from src/components/results/common/global-filter/use-global-filter-results.ts
rename to src/components/results/common/global-filter/hooks/use-global-filter-results.ts
index 1a175704c7..21ec70e41c 100644
--- a/src/components/results/common/global-filter/use-global-filter-results.ts
+++ b/src/components/results/common/global-filter/hooks/use-global-filter-results.ts
@@ -9,12 +9,12 @@ import type { NonEmptyTuple } from 'type-fest';
 import { useCallback, useEffect, useState } from 'react';
 import { useSelector } from 'react-redux';
 import { snackWithFallback, useDebounce, useSnackMessage } from '@gridsuite/commons-ui';
-import type { GlobalFilter } from './global-filter-types';
-import { evaluateGlobalFilter } from '../../../../services/study/filter';
-import type { AppState } from '../../../../redux/reducer.type';
-import type { FilterEquipmentType } from '../../../../types/filter-lib/filter';
-import { isStatusBuilt } from '../../../graph/util/model-functions';
-import { buildValidGlobalFilters } from './build-valid-global-filters';
+import type { GlobalFilter } from '../global-filter.type';
+import { evaluateGlobalFilter } from '../../../../../services/study/filter';
+import type { AppState } from '../../../../../redux/reducer.type';
+import type { FilterEquipmentType } from '../../../../../types/filter-lib/filter';
+import { isStatusBuilt } from '../../../../graph/util/model-functions';
+import { buildValidGlobalFilters } from '../utils/build-valid-global-filters';
 
 /* Because of ESLint react-hooks/rules-of-hooks, nullable value must be managed inside the hook, because
  * React hooks can't be called conditionally and/or different order. */
diff --git a/src/components/results/common/global-filter/use-selected-global-filters.ts b/src/components/results/common/global-filter/hooks/use-selected-global-filters.ts
similarity index 94%
rename from src/components/results/common/global-filter/use-selected-global-filters.ts
rename to src/components/results/common/global-filter/hooks/use-selected-global-filters.ts
index a1973c5184..8a35635aae 100644
--- a/src/components/results/common/global-filter/use-selected-global-filters.ts
+++ b/src/components/results/common/global-filter/hooks/use-selected-global-filters.ts
@@ -7,8 +7,8 @@
 
 import { useMemo } from 'react';
 import { useSelector } from 'react-redux';
-import { GlobalFilter } from './global-filter-types';
-import { RootState, store } from '../../../../redux/store';
+import { GlobalFilter } from '../global-filter.type';
+import { RootState, store } from '../../../../../redux/store';
 
 /**
  * Subscribes to the store and returns the selected global filters for the given table key.
diff --git a/src/components/results/common/global-filter/global-filter-paper.tsx b/src/components/results/common/global-filter/ui/global-filter-dropdown-panel.tsx
similarity index 74%
rename from src/components/results/common/global-filter/global-filter-paper.tsx
rename to src/components/results/common/global-filter/ui/global-filter-dropdown-panel.tsx
index cee978bd3c..c12ec2d78f 100644
--- a/src/components/results/common/global-filter/global-filter-paper.tsx
+++ b/src/components/results/common/global-filter/ui/global-filter-dropdown-panel.tsx
@@ -6,35 +6,25 @@
  */
 
 import { Box, Button, Grid, ListItemButton, Paper, Typography } from '@mui/material';
-import { GLOBAL_FILTERS_CELL_HEIGHT, IMPORT_FILTER_HEIGHT, resultsGlobalFilterStyles } from './global-filter-styles';
+import { GLOBAL_FILTERS_CELL_HEIGHT, IMPORT_FILTER_HEIGHT, resultsGlobalFilterStyles } from '../global-filter.style';
 import { FormattedMessage, useIntl } from 'react-intl';
 import FileUploadIcon from '@mui/icons-material/FileUpload';
-import { PropsWithChildren, RefObject, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { PropsWithChildren, RefObject, useCallback, useMemo, useState } from 'react';
 import ListItemText from '@mui/material/ListItemText';
 import List from '@mui/material/List';
-import { FilterType, isCriteriaFilterType } from '../utils';
-import { GlobalFilter } from './global-filter-types';
-import { fetchSubstationPropertiesGlobalFilters, RECENT_FILTER } from './global-filter-utils';
+import { FilterType, isCriteriaFilterType } from '../../utils';
+import { RECENT_FILTER } from '../utils/global-filter-utils';
 import ClickAwayListener from '@mui/material/ClickAwayListener';
 import {
     DirectoryItemSelector,
-    ElementAttributes,
     ElementType,
     EquipmentType,
-    fetchElementsInfos,
     mergeSx,
     TreeViewFinderNodeProps,
 } from '@gridsuite/commons-ui';
-import { GlobalFilterContext } from './global-filter-context';
 import SelectedGlobalFilters from './selected-global-filters';
-import { TextWithInfoIcon } from './text-with-info-icon';
-import {
-    addToSelectedGlobalFilters,
-    addToGlobalFilterOptions,
-    clearSelectedGlobalFilters,
-} from '../../../../redux/actions';
-import { useDispatch } from 'react-redux';
-import { AppDispatch } from '../../../../redux/store';
+import { LabelWithInfoTooltip } from './label-with-info-tooltip';
+import { useGlobalFilterContext } from '../context/global-filter-context';
 
 const XS_COLUMN1: number = 3;
 const XS_COLUMN2: number = 4;
@@ -42,32 +32,29 @@ const XS_COLUMN3: number = 5;
 
 type GlobalFilterPaperProps = PropsWithChildren<{
     autocompleteRef?: RefObject<HTMLElement | null>;
+    setOpenedDropdown: (open: boolean) => void;
+    filterGroupSelected: string;
+    setFilterGroupSelected: (selectedFilterGroup: string) => void;
 }>;
 
-function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterPaperProps>) {
+function GlobalFilterDropdownPanel({
+    children,
+    autocompleteRef,
+    setOpenedDropdown,
+    filterGroupSelected,
+    setFilterGroupSelected,
+}: Readonly<GlobalFilterPaperProps>) {
+    const intl = useIntl();
+    const [directoryItemSelectorOpen, setDirectoryItemSelectorOpen] = useState(false);
     const {
-        setOpenedDropdown,
-        directoryItemSelectorOpen,
-        setDirectoryItemSelectorOpen,
-        filterGroupSelected,
-        setFilterGroupSelected,
         selectedGlobalFilters,
+        substationPropertiesGlobalFilters,
         filterCategories,
         genericFiltersStrictMode,
         filterableEquipmentTypes,
-        tableType,
-        tableUuid,
-    } = useContext(GlobalFilterContext);
-    const intl = useIntl();
-    const dispatch = useDispatch<AppDispatch>();
-    const [substationPropertiesFilters, setSubstationPropertiesFilters] = useState<Map<string, string[]>>();
-
-    // fetches substation properties global filters from local config
-    useEffect(() => {
-        fetchSubstationPropertiesGlobalFilters().then(({ substationPropertiesGlobalFilters }) => {
-            setSubstationPropertiesFilters(substationPropertiesGlobalFilters);
-        });
-    }, []);
+        clearSelectedGlobalFilters,
+        addFiltersToGlobalFiltersOptions,
+    } = useGlobalFilterContext();
 
     const filteringOnlySubstations = useMemo(() => {
         return filterableEquipmentTypes?.length === 1 && filterableEquipmentTypes[0] === EquipmentType.SUBSTATION;
@@ -99,7 +86,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
     const categories = useMemo(() => {
         const sortedCategories = [
             ...standardCategories,
-            ...(substationPropertiesFilters ? Array.from(substationPropertiesFilters.keys()) : []),
+            ...(substationPropertiesGlobalFilters ? Array.from(substationPropertiesGlobalFilters.keys()) : []),
         ];
         // criteria filters are always at the end of the menu
         const substationCategory: string[] = sortedCategories.splice(
@@ -117,7 +104,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
             sortedCategories.push(genericFilterCategory[0]);
         }
         return sortedCategories;
-    }, [standardCategories, substationPropertiesFilters]);
+    }, [standardCategories, substationPropertiesGlobalFilters]);
 
     const filtersMsg: string = useMemo(
         () =>
@@ -133,45 +120,17 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
         [intl, selectedGlobalFilters.length]
     );
 
-    const addSelectedFilters = useCallback(
+    const addSelectedFiltersToGlobalFiltersOptions = useCallback(
         async (values: TreeViewFinderNodeProps[] | undefined) => {
             if (!values) {
                 return;
             }
 
             setOpenedDropdown(true);
-
-            const elements: ElementAttributes[] = await fetchElementsInfos(values.map((value) => value.id));
-            const newlySelectedFilters: GlobalFilter[] = [];
-            elements.forEach((element: ElementAttributes) => {
-                // ignore already selected filters and non-generic filters :
-                if (!selectedGlobalFilters.find((filter) => filter.uuid && filter.uuid === element.elementUuid)) {
-                    // add the others
-                    const substationOrVoltageLevel =
-                        element.specificMetadata?.equipmentType === EquipmentType.SUBSTATION ||
-                        element.specificMetadata?.equipmentType === EquipmentType.VOLTAGE_LEVEL;
-                    newlySelectedFilters.push({
-                        id: element.elementUuid,
-                        uuid: element.elementUuid,
-                        equipmentType: element.specificMetadata?.equipmentType,
-                        label: element.elementName,
-                        filterType: substationOrVoltageLevel ? FilterType.SUBSTATION_OR_VL : FilterType.GENERIC_FILTER,
-                        filterTypeFromMetadata: element.specificMetadata?.type,
-                    });
-                }
-            });
-
-            dispatch(addToGlobalFilterOptions(newlySelectedFilters));
-            dispatch(
-                addToSelectedGlobalFilters(
-                    tableType,
-                    tableUuid,
-                    newlySelectedFilters.map((f) => f.id)
-                )
-            );
+            await addFiltersToGlobalFiltersOptions(values.map((value) => value.id));
             setDirectoryItemSelectorOpen(false);
         },
-        [selectedGlobalFilters, setDirectoryItemSelectorOpen, setOpenedDropdown, dispatch, tableType, tableUuid]
+        [addFiltersToGlobalFiltersOptions, setDirectoryItemSelectorOpen, setOpenedDropdown]
     );
 
     /**
@@ -209,7 +168,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
                 <Paper sx={resultsGlobalFilterStyles.dropdown}>
                     <Grid container>
                         <Grid item xs={XS_COLUMN1} sx={resultsGlobalFilterStyles.cellHeader}>
-                            <TextWithInfoIcon
+                            <LabelWithInfoTooltip
                                 text="results.globalFilter.categories"
                                 tooltipMessage="results.globalFilter.categoriesHelp"
                             />
@@ -219,7 +178,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
                             <Typography variant="caption">{filtersMsg}</Typography>
                             <Button
                                 size="small"
-                                onClick={() => dispatch(clearSelectedGlobalFilters(tableType, tableUuid))}
+                                onClick={clearSelectedGlobalFilters}
                                 sx={resultsGlobalFilterStyles.miniButton}
                                 data-testid="GlobalFilterClearAllButton"
                             >
@@ -243,7 +202,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
                                             <ListItemText
                                                 primary={
                                                     category === 'genericFilter' ? (
-                                                        <TextWithInfoIcon
+                                                        <LabelWithInfoTooltip
                                                             text={
                                                                 filteringOnlySubstations
                                                                     ? 'results.globalFilter.substationFilter'
@@ -292,7 +251,7 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
             </ClickAwayListener>
             <DirectoryItemSelector
                 open={directoryItemSelectorOpen}
-                onClose={addSelectedFilters}
+                onClose={addSelectedFiltersToGlobalFiltersOptions}
                 types={[ElementType.FILTER]}
                 equipmentTypes={allowedEquipmentTypes}
                 title={intl.formatMessage({ id: 'Filters' })}
@@ -302,4 +261,4 @@ function GlobalFilterPaper({ children, autocompleteRef }: Readonly<GlobalFilterP
     );
 }
 
-export default GlobalFilterPaper;
+export default GlobalFilterDropdownPanel;
diff --git a/src/components/results/common/global-filter/global-filter-autocomplete.tsx b/src/components/results/common/global-filter/ui/global-filter.tsx
similarity index 86%
rename from src/components/results/common/global-filter/global-filter-autocomplete.tsx
rename to src/components/results/common/global-filter/ui/global-filter.tsx
index b909a79365..ea83e30e81 100644
--- a/src/components/results/common/global-filter/global-filter-autocomplete.tsx
+++ b/src/components/results/common/global-filter/ui/global-filter.tsx
@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import React, { useCallback, useContext, useMemo, useRef } from 'react';
+import React, { useCallback, useMemo, useRef, useState } from 'react';
 import {
     Autocomplete,
     AutocompleteChangeDetails,
@@ -26,23 +26,14 @@ import {
 } from '@mui/material';
 import { Delete as DeleteIcon, FilterAlt, WarningAmberRounded } from '@mui/icons-material';
 import { useIntl } from 'react-intl';
-import { useLocalizedCountries } from 'components/utils/localized-countries-hook';
-import { useDispatch } from 'react-redux';
-import { FilterType } from '../utils';
+import { FilterType } from '../../utils';
 import { EquipmentType, OverflowableChip, OverflowableText } from '@gridsuite/commons-ui';
-import { GlobalFilter } from './global-filter-types';
-import { getResultsGlobalFiltersChipStyle, resultsGlobalFilterStyles } from './global-filter-styles';
-import GlobalFilterPaper from './global-filter-paper';
+import type { GlobalFilter } from '../global-filter.type';
+import { getResultsGlobalFiltersChipStyle, resultsGlobalFilterStyles } from '../global-filter.style';
+import GlobalFilterDropdownPanel from './global-filter-dropdown-panel';
 import IconButton from '@mui/material/IconButton';
-import { getOptionLabel, RECENT_FILTER } from './global-filter-utils';
-import { GlobalFilterContext } from './global-filter-context';
-import {
-    addToSelectedGlobalFilters,
-    clearSelectedGlobalFilters,
-    removeFromGlobalFilterOptions,
-    removeFromSelectedGlobalFilters,
-} from '../../../../redux/actions';
-import { AppDispatch } from '../../../../redux/store';
+import { getOptionLabel, RECENT_FILTER } from '../utils/global-filter-utils';
+import { useGlobalFilterContext } from '../context/global-filter-context';
 
 const TAG_LIMIT_NUMBER: number = 4;
 
@@ -99,10 +90,9 @@ function RenderOption({
 }) {
     const { children, ...otherProps } = props;
     const intl = useIntl();
-    const dispatch = useDispatch<AppDispatch>();
-    const { translate } = useLocalizedCountries();
+    const { removeGlobalFilterOption, translateCountryCode } = useGlobalFilterContext();
 
-    const label = getOptionLabel(option, translate, intl) ?? '';
+    const label = getOptionLabel(option, translateCountryCode, intl) ?? '';
 
     let content: React.ReactNode;
     switch (option.filterType) {
@@ -127,7 +117,7 @@ function RenderOption({
                         }}
                         onClick={(e) => {
                             e.stopPropagation();
-                            dispatch(removeFromGlobalFilterOptions(option.id));
+                            removeGlobalFilterOption(option.id);
                         }}
                     >
                         <DeleteIcon fontSize="small" />
@@ -175,24 +165,23 @@ function WarningTooltip({ warningEquipmentTypeMessage }: Readonly<WarningTooltip
     );
 }
 
-function GlobalFilterAutocomplete() {
+function GlobalFilter() {
     const {
-        openedDropdown,
-        setOpenedDropdown,
-        filterGroupSelected,
-        genericFiltersStrictMode,
-        tableType,
-        tableUuid,
         globalFilterOptions,
         selectedGlobalFilters,
         recentGlobalFilters,
         filterCategories,
+        genericFiltersStrictMode,
         filterableEquipmentTypes,
-    } = useContext(GlobalFilterContext);
+        selectGlobalFilter,
+        unselectGlobalFilters,
+        clearSelectedGlobalFilters,
+        translateCountryCode,
+    } = useGlobalFilterContext();
     const intl = useIntl();
-    const { translate } = useLocalizedCountries();
-    const dispatch = useDispatch();
     const autocompleteRef = useRef<HTMLDivElement | null>(null);
+    const [openedDropdown, setOpenedDropdown] = useState(false);
+    const [filterGroupSelected, setFilterGroupSelected] = useState<string>(FilterType.VOLTAGE_LEVEL);
 
     // checks the generic filter to see if they are applicable to the current tab
     const warningEquipmentTypeMessage: string = useMemo(() => {
@@ -232,7 +221,7 @@ function GlobalFilterAutocomplete() {
                 // Allows to find the translated countries (and not their countryCodes) when the user inputs a search value
                 .filter((option: GlobalFilter) => {
                     const labelToMatch: string =
-                        option.filterType === FilterType.COUNTRY ? translate(option.label) : option.label;
+                        option.filterType === FilterType.COUNTRY ? translateCountryCode(option.label) : option.label;
                     return labelToMatch.toLowerCase().includes(state.inputValue.toLowerCase());
                 })
                 .filter((option: GlobalFilter) => {
@@ -267,7 +256,7 @@ function GlobalFilterAutocomplete() {
 
             return filteredOptions;
         },
-        [filterGroupSelected, translate, filterableEquipmentTypes, recentGlobalFilters]
+        [filterGroupSelected, translateCountryCode, filterableEquipmentTypes, recentGlobalFilters]
     );
 
     const options = useMemo(
@@ -284,18 +273,24 @@ function GlobalFilterAutocomplete() {
                 .sort((a: GlobalFilter, b: GlobalFilter) => {
                     // only the countries are sorted alphabetically
                     if (a.filterType === FilterType.COUNTRY && b.filterType === FilterType.COUNTRY) {
-                        const bt: string = translate(b.label);
-                        const at: string = translate(a.label);
+                        const bt: string = translateCountryCode(b.label);
+                        const at: string = translateCountryCode(a.label);
                         return at.localeCompare(bt);
                     }
                     return 0;
                 }),
-        [globalFilterOptions, translate, filterCategories, genericFiltersStrictMode, filterableEquipmentTypes]
+        [
+            globalFilterOptions,
+            translateCountryCode,
+            filterCategories,
+            genericFiltersStrictMode,
+            filterableEquipmentTypes,
+        ]
     );
 
     const inputFieldChip = useCallback(
         (element: GlobalFilter, index: number, getTagsProps: AutocompleteRenderGetTagProps, filtersNumber: number) => {
-            const label = getOptionLabel(element, translate, intl);
+            const label = getOptionLabel(element, translateCountryCode, intl);
             const key: string = `inputFieldChip_${element.label}`;
             if (index < TAG_LIMIT_NUMBER) {
                 return (
@@ -315,14 +310,22 @@ function GlobalFilterAutocomplete() {
 
             return undefined;
         },
-        [translate, intl]
+        [translateCountryCode, intl]
     );
 
     const isOptionEqualToValue = useCallback((option: GlobalFilter, value: GlobalFilter) => option.id === value.id, []);
 
     const PaperComponentMemo = useCallback(
-        (props: PaperProps) => <GlobalFilterPaper {...props} autocompleteRef={autocompleteRef} />,
-        [autocompleteRef]
+        (props: PaperProps) => (
+            <GlobalFilterDropdownPanel
+                {...props}
+                autocompleteRef={autocompleteRef}
+                setOpenedDropdown={setOpenedDropdown}
+                filterGroupSelected={filterGroupSelected}
+                setFilterGroupSelected={setFilterGroupSelected}
+            />
+        ),
+        [autocompleteRef, filterGroupSelected]
     );
 
     const handleOnChange = useCallback(
@@ -334,19 +337,19 @@ function GlobalFilterAutocomplete() {
         ) => {
             switch (reason) {
                 case 'selectOption':
-                    dispatch(addToSelectedGlobalFilters(tableType, tableUuid, [details!.option.id]));
+                    selectGlobalFilter(details!.option.id);
                     break;
                 case 'removeOption':
-                    dispatch(removeFromSelectedGlobalFilters(tableType, tableUuid, [details!.option.id]));
+                    unselectGlobalFilters([details!.option.id]);
                     break;
                 case 'clear':
-                    dispatch(clearSelectedGlobalFilters(tableType, tableUuid));
+                    clearSelectedGlobalFilters();
                     break;
                 default:
                     break;
             }
         },
-        [dispatch, tableType, tableUuid]
+        [clearSelectedGlobalFilters, selectGlobalFilter, unselectGlobalFilters]
     );
 
     return (
@@ -421,4 +424,4 @@ function GlobalFilterAutocomplete() {
     );
 }
 
-export default GlobalFilterAutocomplete;
+export default GlobalFilter;
diff --git a/src/components/results/common/global-filter/text-with-info-icon.tsx b/src/components/results/common/global-filter/ui/label-with-info-tooltip.tsx
similarity index 85%
rename from src/components/results/common/global-filter/text-with-info-icon.tsx
rename to src/components/results/common/global-filter/ui/label-with-info-tooltip.tsx
index 4564b6b418..5ec8a73b30 100644
--- a/src/components/results/common/global-filter/text-with-info-icon.tsx
+++ b/src/components/results/common/global-filter/ui/label-with-info-tooltip.tsx
@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { resultsGlobalFilterStyles } from './global-filter-styles';
+import { resultsGlobalFilterStyles } from '../global-filter.style';
 import { Box, Tooltip } from '@mui/material';
 import { FormattedMessage, useIntl } from 'react-intl';
 import { Info } from '@mui/icons-material';
@@ -15,7 +15,7 @@ type TextWithToolTipProps = {
     tooltipMessage: string;
 };
 
-export function TextWithInfoIcon({ text, tooltipMessage }: Readonly<TextWithToolTipProps>) {
+export function LabelWithInfoTooltip({ text, tooltipMessage }: Readonly<TextWithToolTipProps>) {
     const intl = useIntl();
 
     return (
diff --git a/src/components/results/common/global-filter/selected-global-filters.tsx b/src/components/results/common/global-filter/ui/selected-global-filters.tsx
similarity index 82%
rename from src/components/results/common/global-filter/selected-global-filters.tsx
rename to src/components/results/common/global-filter/ui/selected-global-filters.tsx
index 7f573921d5..4f23ec108a 100644
--- a/src/components/results/common/global-filter/selected-global-filters.tsx
+++ b/src/components/results/common/global-filter/ui/selected-global-filters.tsx
@@ -5,24 +5,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { GlobalFilter } from './global-filter-types';
+import { GlobalFilter } from '../global-filter.type';
 import { EquipmentType, OverflowableChip } from '@gridsuite/commons-ui';
-import { getResultsGlobalFiltersChipStyle, resultsGlobalFilterStyles } from './global-filter-styles';
+import { getResultsGlobalFiltersChipStyle, resultsGlobalFilterStyles } from '../global-filter.style';
 import { Box, Divider, List, ListItem, Typography } from '@mui/material';
-import { getOptionLabel } from './global-filter-utils';
-import { useContext } from 'react';
-import { GlobalFilterContext } from './global-filter-context';
-import { useLocalizedCountries } from '../../../utils/localized-countries-hook';
+import { getOptionLabel } from '../utils/global-filter-utils';
 import { FormattedMessage, useIntl } from 'react-intl';
-import { FilterType } from '../utils';
-import { removeFromSelectedGlobalFilters } from '../../../../redux/actions';
-import { useDispatch } from 'react-redux';
+import { FilterType } from '../../utils';
+import { useGlobalFilterContext } from '../context/global-filter-context';
 
 function SelectedGlobalFilters() {
-    const { selectedGlobalFilters, tableType, tableUuid } = useContext(GlobalFilterContext);
-    const { translate } = useLocalizedCountries();
+    const { selectedGlobalFilters, translateCountryCode, unselectGlobalFilters } = useGlobalFilterContext();
     const intl = useIntl();
-    const dispatch = useDispatch();
 
     const filtersByCategories: Map<string, GlobalFilter[]> = new Map();
     selectedGlobalFilters.forEach((filter: GlobalFilter) => {
@@ -74,10 +68,10 @@ function SelectedGlobalFilters() {
                         {filters.map((element: GlobalFilter) => (
                             <OverflowableChip
                                 key={element.id}
-                                label={getOptionLabel(element, translate, intl)}
+                                label={getOptionLabel(element, translateCountryCode, intl)}
                                 sx={getResultsGlobalFiltersChipStyle(element)}
                                 onDelete={() => {
-                                    dispatch(removeFromSelectedGlobalFilters(tableType, tableUuid, [element.id]));
+                                    unselectGlobalFilters([element.id]);
                                 }}
                             />
                         ))}
diff --git a/src/components/results/common/global-filter/build-valid-global-filters.ts b/src/components/results/common/global-filter/utils/build-valid-global-filters.ts
similarity index 96%
rename from src/components/results/common/global-filter/build-valid-global-filters.ts
rename to src/components/results/common/global-filter/utils/build-valid-global-filters.ts
index adac3f1d71..c9f9c501fd 100644
--- a/src/components/results/common/global-filter/build-valid-global-filters.ts
+++ b/src/components/results/common/global-filter/utils/build-valid-global-filters.ts
@@ -5,8 +5,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { GlobalFilter, GlobalFilters } from './global-filter-types';
-import { FilterType } from '../utils';
+import { GlobalFilter, GlobalFilters } from '../global-filter.type';
+import { FilterType } from '../../utils';
 
 /**
  * Transforms global filters stored by the frontend into the format expected by the filter server.
diff --git a/src/components/results/common/global-filter/utils/global-filter-state.utils.ts b/src/components/results/common/global-filter/utils/global-filter-state.utils.ts
new file mode 100644
index 0000000000..3d32a3c776
--- /dev/null
+++ b/src/components/results/common/global-filter/utils/global-filter-state.utils.ts
@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { GlobalFilter, RecentGlobalFilter } from '../global-filter.type';
+
+export const MAX_RECENT_GLOBAL_FILTERS = 10;
+
+export type GlobalFilterTableState = {
+    selected: string[];
+    recents: RecentGlobalFilter[];
+};
+
+const EMPTY_GLOBAL_FILTER_TABLE_STATE: GlobalFilterTableState = { selected: [], recents: [] };
+
+function ensureGlobalFilterTableState(tableState?: GlobalFilterTableState): GlobalFilterTableState {
+    return tableState ?? EMPTY_GLOBAL_FILTER_TABLE_STATE;
+}
+
+export function addSelectedGlobalFiltersToTableState(
+    tableState: GlobalFilterTableState | undefined,
+    filterIds: string[]
+): GlobalFilterTableState {
+    const currentTableState = ensureGlobalFilterTableState(tableState);
+    const selected = [...currentTableState.selected];
+    let recents = currentTableState.recents;
+
+    filterIds.forEach((id) => {
+        if (!selected.includes(id)) {
+            selected.push(id);
+        }
+        recents = recents.filter((recentFilter) => recentFilter.id !== id);
+    });
+
+    return {
+        selected,
+        recents,
+    };
+}
+
+export function removeSelectedGlobalFiltersFromTableState(
+    tableState: GlobalFilterTableState | undefined,
+    filterIds: string[],
+    globalFilterOptions: GlobalFilter[],
+    unselectedDate: number = Date.now()
+): GlobalFilterTableState {
+    const currentTableState = ensureGlobalFilterTableState(tableState);
+    const selected = currentTableState.selected.filter((id) => !filterIds.includes(id));
+    const recents = [...currentTableState.recents];
+
+    filterIds.forEach((filterId) => {
+        const filterOption = globalFilterOptions.find((opt) => opt.id === filterId);
+        if (!filterOption?.deleted) {
+            recents.unshift({ id: filterId, unselectedDate });
+        }
+    });
+
+    return {
+        selected,
+        recents: recents.slice(0, MAX_RECENT_GLOBAL_FILTERS),
+    };
+}
+
+export function clearSelectedGlobalFiltersFromTableState(
+    tableState: GlobalFilterTableState | undefined,
+    globalFilterOptions: GlobalFilter[],
+    unselectedDate: number = Date.now()
+): GlobalFilterTableState {
+    const currentTableState = ensureGlobalFilterTableState(tableState);
+    const newRecents = currentTableState.selected
+        .filter((filterId) => {
+            const filterOption = globalFilterOptions.find((opt) => opt.id === filterId);
+            return !filterOption?.deleted;
+        })
+        .map((filterId) => ({ id: filterId, unselectedDate }));
+
+    return {
+        selected: [],
+        recents: [...newRecents, ...currentTableState.recents].slice(0, MAX_RECENT_GLOBAL_FILTERS),
+    };
+}
+
+export type MarkNotFoundGlobalFiltersAsDeletedResult = {
+    globalFilterOptions: GlobalFilter[];
+    tableState?: GlobalFilterTableState;
+};
+
+export function markNotFoundGlobalFiltersAsDeletedInState(
+    globalFilterOptions: GlobalFilter[],
+    tableState: GlobalFilterTableState | undefined,
+    notFoundGlobalFilters: GlobalFilter[]
+): MarkNotFoundGlobalFiltersAsDeletedResult {
+    const ids = new Set(notFoundGlobalFilters.map((filter) => filter.id));
+    const updatedGlobalFilterOptions = globalFilterOptions.map((globalFilter) =>
+        ids.has(globalFilter.id) ? { ...globalFilter, deleted: true } : globalFilter
+    );
+
+    if (!tableState) {
+        return {
+            globalFilterOptions: updatedGlobalFilterOptions,
+        };
+    }
+
+    return {
+        globalFilterOptions: updatedGlobalFilterOptions,
+        tableState: {
+            selected: tableState.selected,
+            recents: tableState.recents?.length
+                ? tableState.recents.filter((recentFilter) => !ids.has(recentFilter.id))
+                : tableState.recents,
+        },
+    };
+}
diff --git a/src/components/results/common/global-filter/utils/global-filter-sync.utils.ts b/src/components/results/common/global-filter/utils/global-filter-sync.utils.ts
new file mode 100644
index 0000000000..a4434b62c8
--- /dev/null
+++ b/src/components/results/common/global-filter/utils/global-filter-sync.utils.ts
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { GlobalFilter } from '../global-filter.type';
+import { markEditingGlobalFilter, unmarkEditingGlobalFilter } from '../../../../../utils/editing-global-filter-sync';
+
+const DEFAULT_GLOBAL_FILTER_SYNC_DEBOUNCE_MS = 2000;
+
+const debouncedSyncTimers: Record<string, ReturnType<typeof setTimeout>> = {};
+
+export type SyncGlobalFiltersParameters = {
+    index: string;
+    globalFilters: GlobalFilter[];
+    save: (globalFilters: GlobalFilter[]) => Promise<unknown>;
+    onError: (error: unknown) => void;
+    debounceMs?: number;
+};
+
+export function syncGlobalFilters({
+    index,
+    globalFilters,
+    save,
+    onError,
+    debounceMs = DEFAULT_GLOBAL_FILTER_SYNC_DEBOUNCE_MS,
+}: SyncGlobalFiltersParameters): void {
+    markEditingGlobalFilter(index);
+
+    if (debouncedSyncTimers[index]) {
+        clearTimeout(debouncedSyncTimers[index]);
+    }
+
+    debouncedSyncTimers[index] = setTimeout(() => {
+        save(globalFilters)
+            .catch(onError)
+            .finally(() => {
+                // Only end the sync if no new debounce timer was started while the save was in flight.
+                if (!debouncedSyncTimers[index]) {
+                    unmarkEditingGlobalFilter(index);
+                }
+            });
+
+        delete debouncedSyncTimers[index];
+    }, debounceMs);
+}
diff --git a/src/components/results/common/global-filter/global-filter-utils.ts b/src/components/results/common/global-filter/utils/global-filter-utils.ts
similarity index 74%
rename from src/components/results/common/global-filter/global-filter-utils.ts
rename to src/components/results/common/global-filter/utils/global-filter-utils.ts
index c45e79ef2a..5f16804695 100644
--- a/src/components/results/common/global-filter/global-filter-utils.ts
+++ b/src/components/results/common/global-filter/utils/global-filter-utils.ts
@@ -5,9 +5,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { GlobalFilter } from './global-filter-types';
-import { FilterType } from '../utils';
-import { fetchStudyMetadata } from '@gridsuite/commons-ui';
+import { GlobalFilter } from '../global-filter.type';
+import { FilterType } from '../../utils';
 import { IntlShape } from 'react-intl';
 import { UUID } from 'node:crypto';
 
@@ -58,15 +57,3 @@ export const getOptionLabel = (
     }
     return '';
 };
-
-export async function fetchSubstationPropertiesGlobalFilters(): Promise<{
-    substationPropertiesGlobalFilters?: Map<string, string[]>;
-}> {
-    const { substationPropertiesGlobalFilters } = await fetchStudyMetadata();
-    const definedSubstationPropertiesGlobalFilters: Map<string, string[]> = substationPropertiesGlobalFilters
-        ? new Map(Object.entries(substationPropertiesGlobalFilters))
-        : new Map<string, string[]>();
-    return {
-        substationPropertiesGlobalFilters: definedSubstationPropertiesGlobalFilters,
-    };
-}
diff --git a/src/components/results/common/utils.ts b/src/components/results/common/utils.ts
index ed24f38f49..725e6e06c2 100644
--- a/src/components/results/common/utils.ts
+++ b/src/components/results/common/utils.ts
@@ -8,7 +8,7 @@ import { NA_Value } from 'components/custom-aggrid/utils/format-values-utils';
 import { IntlShape } from 'react-intl';
 import type { MuiStyles } from '@gridsuite/commons-ui';
 import { FilterConfig, SortConfig, TableType } from 'types/custom-aggrid-types';
-import { GlobalFilter } from './global-filter/global-filter-types';
+import { GlobalFilter } from './global-filter/global-filter.type';
 import { Dispatch } from 'redux';
 import { UUID } from 'node:crypto';
 import {
diff --git a/src/components/results/loadflow/load-flow-result-tab.tsx b/src/components/results/loadflow/load-flow-result-tab.tsx
index 1c8f0a4615..51ca4268ee 100644
--- a/src/components/results/loadflow/load-flow-result-tab.tsx
+++ b/src/components/results/loadflow/load-flow-result-tab.tsx
@@ -41,14 +41,14 @@ import { loadflowResultInvalidations } from '../../computing-status/use-all-comp
 import { useNodeData } from 'components/use-node-data';
 import type { UUID } from 'node:crypto';
 import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 import { Button, LinearProgress } from '@mui/material';
 import { ICellRendererParams } from 'ag-grid-community';
 import { resultsStyles } from '../common/utils';
 import { useLoadFlowResultColumnActions } from './use-load-flow-result-column-actions';
 import { useOpenLoaderShortWait } from '../../dialogs/commons/handle-loader';
 import { RESULTS_LOADING_DELAY } from '../../network/constants';
-import { useComputationGlobalFilters } from '../common/global-filter/use-computation-global-filters';
+import { useComputationGlobalFilters } from '../common/global-filter/hooks/use-computation-global-filters';
 import { useComputationColumnFilters } from '../common/column-filter/use-computation-column-filters';
 
 const styles = {
diff --git a/src/components/results/pccmin/pcc-min-export-button.tsx b/src/components/results/pccmin/pcc-min-export-button.tsx
index 7f559f3ee0..c1b801726d 100644
--- a/src/components/results/pccmin/pcc-min-export-button.tsx
+++ b/src/components/results/pccmin/pcc-min-export-button.tsx
@@ -18,9 +18,9 @@ import { mapFieldsToColumnsFilter } from 'utils/aggrid-headers-utils';
 import { exportPccMinResultsAsCsv } from 'services/study/pcc-min';
 import { FROM_COLUMN_TO_FIELD_PCC_MIN } from './pcc-min-result.type';
 import { PARAM_COMPUTED_LANGUAGE } from '../../../utils/config-params';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 
-import { getSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
+import { getSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
 
 interface PccMinExportButtonProps {
     studyUuid: UUID;
diff --git a/src/components/results/pccmin/pcc-min-result-tab.tsx b/src/components/results/pccmin/pcc-min-result-tab.tsx
index 2fd2d9ee12..17577071e3 100644
--- a/src/components/results/pccmin/pcc-min-result-tab.tsx
+++ b/src/components/results/pccmin/pcc-min-result-tab.tsx
@@ -19,7 +19,7 @@ import { RESULTS_LOADING_DELAY } from '../../network/constants';
 import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
 import { PccMinResultTabProps } from './pcc-min-result.type';
 import { PccMinResult } from './pcc-min-result';
-import { useComputationGlobalFilters } from '../common/global-filter/use-computation-global-filters';
+import { useComputationGlobalFilters } from '../common/global-filter/hooks/use-computation-global-filters';
 import { PaginationType, TableType } from '../../../types/custom-aggrid-types';
 import { usePaginationSelector } from '../../../hooks/use-pagination-selector';
 import { PCCMIN_RESULT } from '../../../utils/store-sort-filter-fields';
diff --git a/src/components/results/pccmin/pcc-min-result.tsx b/src/components/results/pccmin/pcc-min-result.tsx
index b44c93eca2..6b79d80235 100644
--- a/src/components/results/pccmin/pcc-min-result.tsx
+++ b/src/components/results/pccmin/pcc-min-result.tsx
@@ -28,8 +28,8 @@ import { PCCMIN_ANALYSIS_RESULT_SORT_STORE, PCCMIN_RESULT } from 'utils/store-so
 import { fetchPccMinPagedResults } from 'services/study/pcc-min';
 import { UUID } from 'node:crypto';
 import { PccMinExportButton } from './pcc-min-export-button';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
-import { useSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
+import { useSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
 import { useComputationColumnFilters } from '../common/column-filter/use-computation-column-filters';
 
 interface PccMinResultProps {
diff --git a/src/components/results/pccmin/pcc-min-result.type.ts b/src/components/results/pccmin/pcc-min-result.type.ts
index bcf07b40f1..e41261a6c4 100644
--- a/src/components/results/pccmin/pcc-min-result.type.ts
+++ b/src/components/results/pccmin/pcc-min-result.type.ts
@@ -6,7 +6,7 @@
  */
 
 import type { UUID } from 'node:crypto';
-import { GlobalFilters } from '../common/global-filter/global-filter-types';
+import { GlobalFilters } from '../common/global-filter/global-filter.type';
 import { Page, Selector } from '../common/utils';
 import { ColumnContext, numericFilterParams, TableType, textFilterParams } from 'types/custom-aggrid-types';
 import { CustomAggridComparatorFilter } from 'components/custom-aggrid/custom-aggrid-filters/custom-aggrid-comparator-filter';
diff --git a/src/components/results/securityanalysis/security-analysis-result-tab.tsx b/src/components/results/securityanalysis/security-analysis-result-tab.tsx
index 04db2feb5b..a32e08a6dc 100644
--- a/src/components/results/securityanalysis/security-analysis-result-tab.tsx
+++ b/src/components/results/securityanalysis/security-analysis-result-tab.tsx
@@ -47,8 +47,8 @@ import { useNodeData } from 'components/use-node-data';
 import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
 import { usePaginationSelector } from 'hooks/use-pagination-selector';
 import { UUID } from 'node:crypto';
-import { useComputationGlobalFilters } from '../common/global-filter/use-computation-global-filters';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { useComputationGlobalFilters } from '../common/global-filter/hooks/use-computation-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 import { useComputationColumnFilters } from '../common/column-filter/use-computation-column-filters';
 import { FilterType, isCriteriaFilterType } from '../common/utils';
 import { setTableSort } from '../../../redux/actions';
diff --git a/src/components/results/securityanalysis/security-analysis.type.ts b/src/components/results/securityanalysis/security-analysis.type.ts
index ed4655d353..cc33a8c45b 100644
--- a/src/components/results/securityanalysis/security-analysis.type.ts
+++ b/src/components/results/securityanalysis/security-analysis.type.ts
@@ -9,7 +9,7 @@ import * as React from 'react';
 import { ColDef, GridReadyEvent, ICellRendererParams } from 'ag-grid-community';
 import type { UUID } from 'node:crypto';
 import { FilterConfig, SortConfig } from '../../../types/custom-aggrid-types';
-import { GlobalFilters } from '../common/global-filter/global-filter-types';
+import { GlobalFilters } from '../common/global-filter/global-filter.type';
 import { RunningStatusMessage } from '../../utils/aggrid-rows-handler';
 import RunningStatus from '../../utils/running-status';
 import { LimitViolation } from '@gridsuite/commons-ui';
diff --git a/src/components/results/sensitivity-analysis/paged-sensitivity-analysis-result.tsx b/src/components/results/sensitivity-analysis/paged-sensitivity-analysis-result.tsx
index 53027827fa..ef110abb3a 100644
--- a/src/components/results/sensitivity-analysis/paged-sensitivity-analysis-result.tsx
+++ b/src/components/results/sensitivity-analysis/paged-sensitivity-analysis-result.tsx
@@ -37,8 +37,8 @@ import { SensiKind, SENSITIVITY_AT_NODE } from './sensitivity-analysis-result.ty
 import { AppState } from '../../../redux/reducer.type';
 import { SensitivityResult, SensitivityResultFilterOptions } from '../../../services/study/sensitivity-analysis.type';
 import { usePaginationSelector } from 'hooks/use-pagination-selector';
-import { useSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { useSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 import { useComputationColumnFilters } from '../common/column-filter/use-computation-column-filters';
 
 export type PagedSensitivityAnalysisResultProps = {
diff --git a/src/components/results/sensitivity-analysis/sensitivity-analysis-export-button.tsx b/src/components/results/sensitivity-analysis/sensitivity-analysis-export-button.tsx
index 1dad49d24f..9d70312bdf 100644
--- a/src/components/results/sensitivity-analysis/sensitivity-analysis-export-button.tsx
+++ b/src/components/results/sensitivity-analysis/sensitivity-analysis-export-button.tsx
@@ -25,10 +25,10 @@ import { SensiKind } from './sensitivity-analysis-result.type';
 import { SortWay, TableType } from '../../../types/custom-aggrid-types';
 import { SENSITIVITY_ANALYSIS_RESULT_SORT_STORE } from 'utils/store-sort-filter-fields';
 import { PARAM_COMPUTED_LANGUAGE } from '../../../utils/config-params';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 import { getColumnFiltersFromStore } from '../../../redux/selectors/filter-store-selectors';
 
-import { getSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
+import { getSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
 
 interface SensitivityExportButtonProps {
     studyUuid: UUID;
diff --git a/src/components/results/sensitivity-analysis/sensitivity-analysis-result-tab.tsx b/src/components/results/sensitivity-analysis/sensitivity-analysis-result-tab.tsx
index 253b44352c..2f04cd429e 100644
--- a/src/components/results/sensitivity-analysis/sensitivity-analysis-result-tab.tsx
+++ b/src/components/results/sensitivity-analysis/sensitivity-analysis-result-tab.tsx
@@ -26,7 +26,7 @@ import {
 import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
 import { SensitivityExportButton } from './sensitivity-analysis-export-button.js';
 import { isSensiKind, mappingTabs, SensitivityResultTabs } from './sensitivity-analysis-result-utils.js';
-import { useComputationGlobalFilters } from '../common/global-filter/use-computation-global-filters';
+import { useComputationGlobalFilters } from '../common/global-filter/hooks/use-computation-global-filters';
 import { PaginationType, TableType } from '../../../types/custom-aggrid-types';
 import { usePaginationSelector } from '../../../hooks/use-pagination-selector';
 import { FilterType, isCriteriaFilterType } from '../common/utils';
diff --git a/src/components/results/shortcircuit/shortcircuit-analysis-export-button.tsx b/src/components/results/shortcircuit/shortcircuit-analysis-export-button.tsx
index 63699a1920..0079ad3c95 100644
--- a/src/components/results/shortcircuit/shortcircuit-analysis-export-button.tsx
+++ b/src/components/results/shortcircuit/shortcircuit-analysis-export-button.tsx
@@ -29,9 +29,9 @@ import {
 } from './shortcircuit-analysis-result-content';
 import { SHORTCIRCUIT_ANALYSIS_RESULT_SORT_STORE } from '../../../utils/store-sort-filter-fields';
 import { mapFieldsToColumnsFilter } from 'utils/aggrid-headers-utils';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
 
-import { getSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
+import { getSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
 
 interface ShortCircuitExportButtonProps {
     studyUuid: UUID;
diff --git a/src/components/results/shortcircuit/shortcircuit-analysis-result-tab.tsx b/src/components/results/shortcircuit/shortcircuit-analysis-result-tab.tsx
index b28a08f9b9..ce320f97bb 100644
--- a/src/components/results/shortcircuit/shortcircuit-analysis-result-tab.tsx
+++ b/src/components/results/shortcircuit/shortcircuit-analysis-result-tab.tsx
@@ -28,7 +28,7 @@ import { ShortCircuitExportButton } from './shortcircuit-analysis-export-button'
 import type { UUID } from 'node:crypto';
 import { ColDef, GridReadyEvent, RowDataUpdatedEvent } from 'ag-grid-community';
 import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
-import { useComputationGlobalFilters } from '../common/global-filter/use-computation-global-filters';
+import { useComputationGlobalFilters } from '../common/global-filter/hooks/use-computation-global-filters';
 import { PaginationType, ShortcircuitAnalysisTab, TableType } from '../../../types/custom-aggrid-types';
 import { usePaginationSelector } from '../../../hooks/use-pagination-selector';
 import { mappingTabs } from './shortcircuit-analysis-result-content';
diff --git a/src/components/results/shortcircuit/shortcircuit-analysis-result.tsx b/src/components/results/shortcircuit/shortcircuit-analysis-result.tsx
index 57e466b892..b06d7a3049 100644
--- a/src/components/results/shortcircuit/shortcircuit-analysis-result.tsx
+++ b/src/components/results/shortcircuit/shortcircuit-analysis-result.tsx
@@ -40,8 +40,8 @@ import {
 } from '../../../types/custom-aggrid-types';
 import { mapFieldsToColumnsFilter } from '../../../utils/aggrid-headers-utils';
 import { usePaginationSelector } from 'hooks/use-pagination-selector';
-import { buildValidGlobalFilters } from '../common/global-filter/build-valid-global-filters';
-import { useSelectedGlobalFilters } from '../common/global-filter/use-selected-global-filters';
+import { buildValidGlobalFilters } from '../common/global-filter/utils/build-valid-global-filters';
+import { useSelectedGlobalFilters } from '../common/global-filter/hooks/use-selected-global-filters';
 import { useComputationColumnFilters } from '../common/column-filter/use-computation-column-filters';
 
 interface IShortCircuitAnalysisGlobalResultProps {
diff --git a/src/components/spreadsheet-view/add-spreadsheet/dialogs/add-spreadsheet-utils.ts b/src/components/spreadsheet-view/add-spreadsheet/dialogs/add-spreadsheet-utils.ts
index 321faffa91..41dd540777 100644
--- a/src/components/spreadsheet-view/add-spreadsheet/dialogs/add-spreadsheet-utils.ts
+++ b/src/components/spreadsheet-view/add-spreadsheet/dialogs/add-spreadsheet-utils.ts
@@ -29,7 +29,7 @@ import { v4 as uuid4 } from 'uuid';
 import { COLUMN_DEPENDENCIES } from '../../columns/column-creation-form';
 import { TableSortConfig } from '../../../../types/custom-aggrid-types';
 import { addSpreadsheetConfigToCollection } from 'services/study/study-config';
-import { GlobalFilter } from '../../../results/common/global-filter/global-filter-types';
+import { GlobalFilter } from '../../../results/common/global-filter/global-filter.type';
 import { ResetNodeAliasCallback } from '../../hooks/use-node-aliases';
 
 const createNewTableDefinition = (
diff --git a/src/components/spreadsheet-view/spreadsheet/spreadsheet-content/hooks/use-spreadsheet-gs-filter.ts b/src/components/spreadsheet-view/spreadsheet/spreadsheet-content/hooks/use-spreadsheet-gs-filter.ts
index 601a238c5f..673aa5b7db 100644
--- a/src/components/spreadsheet-view/spreadsheet/spreadsheet-content/hooks/use-spreadsheet-gs-filter.ts
+++ b/src/components/spreadsheet-view/spreadsheet/spreadsheet-content/hooks/use-spreadsheet-gs-filter.ts
@@ -11,10 +11,10 @@ import type { UUID } from 'node:crypto';
 import { SpreadsheetEquipmentType } from '../../../types/spreadsheet.type';
 import { type AgGridReact } from 'ag-grid-react';
 import { ROW_INDEX_COLUMN_ID } from '../../../constants';
-import { useGlobalFilterResults } from '../../../../results/common/global-filter/use-global-filter-results';
+import { useGlobalFilterResults } from '../../../../results/common/global-filter/hooks/use-global-filter-results';
 import { FilterEquipmentType } from '../../../../../types/filter-lib/filter';
-import { useSelectedGlobalFilters } from '../../../../results/common/global-filter/use-selected-global-filters';
-import { buildValidGlobalFilters } from '../../../../results/common/global-filter/build-valid-global-filters';
+import { useSelectedGlobalFilters } from '../../../../results/common/global-filter/hooks/use-selected-global-filters';
+import { buildValidGlobalFilters } from '../../../../results/common/global-filter/utils/build-valid-global-filters';
 
 export const refreshSpreadsheetAfterFilterChanged = (event: FilterChangedEvent) => {
     event.api.refreshCells({ columns: [ROW_INDEX_COLUMN_ID], force: true });
diff --git a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/row-counter/use-filtered-row-counter.tsx b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/row-counter/use-filtered-row-counter.tsx
index f4aa0c0214..d9ce813921 100644
--- a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/row-counter/use-filtered-row-counter.tsx
+++ b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/row-counter/use-filtered-row-counter.tsx
@@ -14,7 +14,7 @@ import { useSelector } from 'react-redux';
 import { AppState } from '../../../../../redux/reducer.type';
 import { TableType } from '../../../../../types/custom-aggrid-types';
 import { type FilterChangedEvent, type ModelUpdatedEvent, type RowDataUpdatedEvent } from 'ag-grid-community';
-import { useSelectedGlobalFilters } from '../../../../results/common/global-filter/use-selected-global-filters';
+import { useSelectedGlobalFilters } from '../../../../results/common/global-filter/hooks/use-selected-global-filters';
 import { isCriteriaFilterType } from '../../../../results/common/utils';
 
 type UseFilteredRowCounterInfoParams = {
diff --git a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-collection-dialog.tsx b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-collection-dialog.tsx
index cc1c279297..bd4f6b5aa2 100644
--- a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-collection-dialog.tsx
+++ b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-collection-dialog.tsx
@@ -42,7 +42,7 @@ import { v4 as uuid4 } from 'uuid';
 import { saveSpreadsheetCollection, updateSpreadsheetCollection } from '../../../../../services/explore';
 import { SPREADSHEET_SORT_STORE } from 'utils/store-sort-filter-fields';
 import { SortConfig, TableType } from '../../../../../types/custom-aggrid-types';
-import { GlobalFilter } from '../../../../results/common/global-filter/global-filter-types';
+import { GlobalFilter } from '../../../../results/common/global-filter/global-filter.type';
 import { useNodeAliases } from '../../../hooks/use-node-aliases';
 
 interface SaveSpreadsheetCollectionDialogProps {
diff --git a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-dialog.tsx b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-dialog.tsx
index a56a545c98..7213c9392a 100644
--- a/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-dialog.tsx
+++ b/src/components/spreadsheet-view/spreadsheet/spreadsheet-toolbar/save/save-spreadsheet-dialog.tsx
@@ -24,7 +24,7 @@ import { TableType } from '../../../../../types/custom-aggrid-types';
 import { useNodeAliases } from '../../../hooks/use-node-aliases';
 import { SaveSpreadsheetModelDialog } from './save-spreadsheet-model-dialog';
 
-import { getSelectedGlobalFilters } from '../../../../results/common/global-filter/use-selected-global-filters';
+import { getSelectedGlobalFilters } from '../../../../results/common/global-filter/hooks/use-selected-global-filters';
 
 export type SaveSpreadsheetDialogProps = {
     tableDefinition: SpreadsheetTabDefinition;
diff --git a/src/components/spreadsheet-view/types/spreadsheet.type.ts b/src/components/spreadsheet-view/types/spreadsheet.type.ts
index a0500bb020..4874a84c3d 100644
--- a/src/components/spreadsheet-view/types/spreadsheet.type.ts
+++ b/src/components/spreadsheet-view/types/spreadsheet.type.ts
@@ -7,7 +7,7 @@
 
 import type { UUID } from 'node:crypto';
 import type { Identifiable } from '@gridsuite/commons-ui';
-import type { GlobalFilter } from '../../results/common/global-filter/global-filter-types';
+import type { GlobalFilter } from '../../results/common/global-filter/global-filter.type';
 import { COLUMN_TYPES, SortConfig } from '../../../types/custom-aggrid-types';
 
 // The order of the enum values is important, do not change it without checking the usage (e.g. in select options in AddEmptySpreadsheetDialog)
diff --git a/src/components/voltage-init-result-tab.tsx b/src/components/voltage-init-result-tab.tsx
index 965b5f13dd..0f87641554 100644
--- a/src/components/voltage-init-result-tab.tsx
+++ b/src/components/voltage-init-result-tab.tsx
@@ -15,9 +15,9 @@ import { AppState } from '../redux/reducer.type';
 import { VoltageInitResult } from './voltage-init-result';
 import { useMemo } from 'react';
 import { fetchVoltageInitResult } from '../services/study/voltage-init';
-import { useComputationGlobalFilters } from './results/common/global-filter/use-computation-global-filters';
+import { useComputationGlobalFilters } from './results/common/global-filter/hooks/use-computation-global-filters';
 import { TableType } from '../types/custom-aggrid-types';
-import { buildValidGlobalFilters } from './results/common/global-filter/build-valid-global-filters';
+import { buildValidGlobalFilters } from './results/common/global-filter/utils/build-valid-global-filters';
 
 export type VoltageInitResultTabProps = {
     studyUuid: UUID;
diff --git a/src/redux/actions.ts b/src/redux/actions.ts
index cc852c8432..45b0f82007 100644
--- a/src/redux/actions.ts
+++ b/src/redux/actions.ts
@@ -43,7 +43,7 @@ import {
 } from '../types/custom-aggrid-types';
 import type { RunningStatus } from '../components/utils/running-status';
 import type { IOptionalService } from '../components/utils/optional-services';
-import type { GlobalFilter } from '../components/results/common/global-filter/global-filter-types';
+import type { GlobalFilter } from '../components/results/common/global-filter/global-filter.type';
 import {
     LOGS_PAGINATION_STORE_FIELD,
     PCCMIN_ANALYSIS_PAGINATION_STORE_FIELD,
diff --git a/src/redux/globalFiltersMiddleware.ts b/src/redux/globalFiltersMiddleware.ts
index 854bc48996..451970c64b 100644
--- a/src/redux/globalFiltersMiddleware.ts
+++ b/src/redux/globalFiltersMiddleware.ts
@@ -17,9 +17,7 @@ import { setComputationResultGlobalFilters, setGlobalFiltersToSpreadsheetConfig
 import { TableType } from '../types/custom-aggrid-types';
 import { UUID } from 'node:crypto';
 import type { AppState } from './reducer.type';
-import { markEditingGlobalFilter, unmarkEditingGlobalFilter } from '../utils/editing-global-filter-sync';
-
-const debouncedSyncTimers: Record<string, ReturnType<typeof setTimeout>> = {};
+import { syncGlobalFilters } from '../components/results/common/global-filter/utils/global-filter-sync.utils';
 
 /**
  * Redux middleware that synchronizes global filter changes with the backend.
@@ -49,9 +47,6 @@ export const globalFiltersMiddleware: Middleware<{}, AppState> = (store) => (nex
             }
             const index = tableId ?? tableType;
 
-            // Protection from overriding more recent filters from backend notification
-            markEditingGlobalFilter(index);
-
             const tableFiltersState = state.tableFilters.globalFilters[index];
 
             const selectedFiltersIds = tableFiltersState?.selected ?? [];
@@ -69,30 +64,17 @@ export const globalFiltersMiddleware: Middleware<{}, AppState> = (store) => (nex
 
             const globalFilters = [...selectedGlobalFilters, ...recentGlobalFilters];
 
-            // Debounce per table to avoid excessive requests
-            if (debouncedSyncTimers[index]) {
-                clearTimeout(debouncedSyncTimers[index]);
-            }
-
-            debouncedSyncTimers[index] = setTimeout(() => {
-                const globalFilterPromise =
+            syncGlobalFilters({
+                index,
+                globalFilters,
+                onError: (error) => {
+                    console.error('Failed to save global filters: ', error);
+                },
+                save: (filters) =>
                     tableType === TableType.Spreadsheet
-                        ? setGlobalFiltersToSpreadsheetConfig(studyUuid, tableId as UUID, globalFilters)
-                        : setComputationResultGlobalFilters(studyUuid, tableType, globalFilters);
-
-                globalFilterPromise
-                    .catch((error) => {
-                        console.error('Failed to save global filters: ', error);
-                    })
-                    .finally(() => {
-                        // Only unmark if no new debounce timer was started while the POST was in flight
-                        if (!debouncedSyncTimers[index]) {
-                            unmarkEditingGlobalFilter(index);
-                        }
-                    });
-
-                delete debouncedSyncTimers[index];
-            }, 2000);
+                        ? setGlobalFiltersToSpreadsheetConfig(studyUuid, tableId as UUID, filters)
+                        : setComputationResultGlobalFilters(studyUuid, tableType, filters),
+            });
 
             break;
         }
diff --git a/src/redux/reducer.ts b/src/redux/reducer.ts
index f72f058451..10c51706bf 100644
--- a/src/redux/reducer.ts
+++ b/src/redux/reducer.ts
@@ -291,8 +291,18 @@ import { mapSpreadsheetEquipments } from '../utils/spreadsheet-equipments-mapper
 import { saveStudyNavigationSync } from 'redux/session-storage/navigation-local-storage';
 import { VOLTAGE_LEVEL_ID } from '../components/utils/field-constants';
 import { isCriteriaFilter } from '../components/results/common/utils';
-import { addGlobalFilterId, getGlobalFilterId } from '../components/results/common/global-filter/global-filter-utils';
-import type { GlobalFilter, RecentGlobalFilter } from '../components/results/common/global-filter/global-filter-types';
+import {
+    addGlobalFilterId,
+    getGlobalFilterId,
+} from '../components/results/common/global-filter/utils/global-filter-utils';
+import type { GlobalFilter, RecentGlobalFilter } from '../components/results/common/global-filter/global-filter.type';
+import {
+    addSelectedGlobalFiltersToTableState,
+    clearSelectedGlobalFiltersFromTableState,
+    markNotFoundGlobalFiltersAsDeletedInState,
+    MAX_RECENT_GLOBAL_FILTERS,
+    removeSelectedGlobalFiltersFromTableState,
+} from '../components/results/common/global-filter/utils/global-filter-state.utils';
 
 // Types are defined in reducer.type.ts — import them directly from there
 import {
@@ -347,8 +357,6 @@ function getEquipmentTypeFromUpdateType(updateType: EquipmentUpdateType): Spread
     }
 }
 
-const MAX_RECENT_GLOBAL_FILTERS = 10;
-
 function buildSortedRecents(filters: GlobalFilter[]): RecentGlobalFilter[] {
     return filters
         .map((f) => ({ id: getGlobalFilterId(f), unselectedDate: f.unselectedDate! }))
@@ -1640,60 +1648,42 @@ export const reducer = createReducer(initialState, (builder) => {
     builder.addCase(ADD_GLOBAL_FILTERS, (state, action: AddGlobalFiltersAction) => {
         const { tableId, filterIds } = action;
 
-        state.tableFilters.globalFilters[tableId] ??= { selected: [], recents: [] };
-        const tableState = state.tableFilters.globalFilters[tableId];
-
-        filterIds.forEach((id) => {
-            if (!tableState.selected.includes(id)) {
-                tableState.selected.push(id);
-            }
-            tableState.recents = tableState.recents.filter((r) => r.id !== id);
-        });
+        state.tableFilters.globalFilters[tableId] = addSelectedGlobalFiltersToTableState(
+            state.tableFilters.globalFilters[tableId],
+            filterIds
+        );
     });
 
     builder.addCase(REMOVE_GLOBAL_FILTERS, (state, action: RemoveGlobalFiltersAction) => {
         const { tableId, filterIds } = action;
 
-        state.tableFilters.globalFilters[tableId] ??= { selected: [], recents: [] };
-        const tableState = state.tableFilters.globalFilters[tableId];
-
-        tableState.selected = tableState.selected.filter((id) => !filterIds.includes(id));
-
-        const now = Date.now();
-        filterIds.forEach((filterId) => {
-            const filterOption = state.globalFilterOptions.find((opt) => opt.id === filterId);
-            if (!filterOption?.deleted) {
-                tableState.recents.unshift({ id: filterId, unselectedDate: now });
-            }
-        });
-        tableState.recents = tableState.recents.slice(0, MAX_RECENT_GLOBAL_FILTERS);
+        state.tableFilters.globalFilters[tableId] = removeSelectedGlobalFiltersFromTableState(
+            state.tableFilters.globalFilters[tableId],
+            filterIds,
+            state.globalFilterOptions
+        );
     });
 
     builder.addCase(CLEAR_GLOBAL_FILTERS, (state, action: ClearGlobalFiltersAction) => {
         const { tableId } = action;
-        state.tableFilters.globalFilters[tableId] ??= { selected: [], recents: [] };
-        const tableState = state.tableFilters.globalFilters[tableId];
-        const now = Date.now();
-        const newRecents = tableState.selected
-            .filter((filterId) => {
-                const filterOption = state.globalFilterOptions.find((opt) => opt.id === filterId);
-                return !filterOption?.deleted;
-            })
-            .map((filterId) => ({ id: filterId, unselectedDate: now }));
-        tableState.recents = [...newRecents, ...tableState.recents].slice(0, MAX_RECENT_GLOBAL_FILTERS);
-        tableState.selected = [];
+        state.tableFilters.globalFilters[tableId] = clearSelectedGlobalFiltersFromTableState(
+            state.tableFilters.globalFilters[tableId],
+            state.globalFilterOptions
+        );
     });
     builder.addCase(
         MARK_NOT_FOUND_GLOBAL_FILTERS_AS_DELETED,
         (state, action: MarkNotFoundGlobalFiltersAsDeletedAction) => {
             const { globalFilters, tableId } = action;
-            const ids = new Set(globalFilters.map((f) => f.id));
-            state.globalFilterOptions.forEach((globalFilter) => {
-                if (ids.has(globalFilter.id)) globalFilter.deleted = true;
-            });
-            const tableState = state.tableFilters.globalFilters[tableId];
-            if (tableState?.recents?.length) {
-                tableState.recents = tableState.recents.filter((r) => !ids.has(r.id));
+            const result = markNotFoundGlobalFiltersAsDeletedInState(
+                state.globalFilterOptions,
+                state.tableFilters.globalFilters[tableId],
+                globalFilters
+            );
+
+            state.globalFilterOptions = result.globalFilterOptions;
+            if (result.tableState) {
+                state.tableFilters.globalFilters[tableId] = result.tableState;
             }
         }
     );
diff --git a/src/redux/reducer.type.ts b/src/redux/reducer.type.ts
index f14810cc73..a41d9c8919 100644
--- a/src/redux/reducer.type.ts
+++ b/src/redux/reducer.type.ts
@@ -33,7 +33,7 @@ import type {
 } from '../types/custom-aggrid-types';
 import type { RunningStatus } from '../components/utils/running-status';
 import type { IOptionalService } from '../components/utils/optional-services';
-import type { GlobalFilter, RecentGlobalFilter } from '../components/results/common/global-filter/global-filter-types';
+import type { GlobalFilter, RecentGlobalFilter } from '../components/results/common/global-filter/global-filter.type';
 import type { CopyType } from '../components/network-modification.type';
 import type {
     CurrentTreeNode,
diff --git a/src/services/study/filter.ts b/src/services/study/filter.ts
index b0132d4fc2..f1e31d09f1 100644
--- a/src/services/study/filter.ts
+++ b/src/services/study/filter.ts
@@ -16,7 +16,7 @@ import {
 import type { UUID } from 'node:crypto';
 import { getRequestParamFromList } from '../utils';
 import { getStudyUrlWithNodeUuidAndRootNetworkUuid } from './index';
-import type { GlobalFilters } from '../../components/results/common/global-filter/global-filter-types';
+import type { GlobalFilters } from '../../components/results/common/global-filter/global-filter.type';
 import type { FilterEquipmentType } from '../../types/filter-lib/filter';
 
 /**
diff --git a/src/services/study/loadflow.ts b/src/services/study/loadflow.ts
index 61e074315e..ac586d5661 100644
--- a/src/services/study/loadflow.ts
+++ b/src/services/study/loadflow.ts
@@ -8,7 +8,7 @@
 import { getStudyUrl, getStudyUrlWithNodeUuidAndRootNetworkUuid } from './index';
 import { backendFetch, backendFetchJson, backendFetchText } from '@gridsuite/commons-ui';
 import type { UUID } from 'node:crypto';
-import { ResultsQueryParams } from '../../components/results/common/global-filter/global-filter-types';
+import { ResultsQueryParams } from '../../components/results/common/global-filter/global-filter.type';
 
 export function setLoadFlowParameters(studyUuid: UUID, newParams: any) {
     console.info('set load flow parameters');
diff --git a/src/services/study/pcc-min.ts b/src/services/study/pcc-min.ts
index 473ed6e98b..c5e54e3840 100644
--- a/src/services/study/pcc-min.ts
+++ b/src/services/study/pcc-min.ts
@@ -7,7 +7,7 @@
 
 import { getStudyUrlWithNodeUuidAndRootNetworkUuid } from './index';
 import { backendFetch, backendFetchJson, backendFetchText, GsLangUser } from '@gridsuite/commons-ui';
-import { GlobalFilters } from 'components/results/common/global-filter/global-filter-types';
+import { GlobalFilters } from 'components/results/common/global-filter/global-filter.type';
 import { PccMinPagedResults } from 'components/results/pccmin/pcc-min-result.type';
 import { UUID } from 'node:crypto';
 import { FilterConfig, SortConfig } from 'types/custom-aggrid-types';
diff --git a/src/services/study/sensitivity-analysis.ts b/src/services/study/sensitivity-analysis.ts
index b9c69073ee..013f242e2a 100644
--- a/src/services/study/sensitivity-analysis.ts
+++ b/src/services/study/sensitivity-analysis.ts
@@ -15,7 +15,7 @@ import {
     SensitivityResultFilterOptions,
 } from './sensitivity-analysis.type';
 import { FilterConfig } from '../../types/custom-aggrid-types';
-import { GlobalFilters } from 'components/results/common/global-filter/global-filter-types';
+import { GlobalFilters } from 'components/results/common/global-filter/global-filter.type';
 
 export function startSensitivityAnalysis(
     studyUuid: UUID,
diff --git a/src/services/study/short-circuit-analysis.ts b/src/services/study/short-circuit-analysis.ts
index c50a89d6aa..75f874d0ae 100644
--- a/src/services/study/short-circuit-analysis.ts
+++ b/src/services/study/short-circuit-analysis.ts
@@ -12,7 +12,7 @@ import {
 } from '../../components/results/shortcircuit/shortcircuit-analysis-result.type';
 import { GsLangUser, backendFetch, backendFetchJson, backendFetchText } from '@gridsuite/commons-ui';
 import type { UUID } from 'node:crypto';
-import { GlobalFilters } from '../../components/results/common/global-filter/global-filter-types';
+import { GlobalFilters } from '../../components/results/common/global-filter/global-filter.type';
 import { Selector } from 'components/results/common/utils';
 
 const PREFIX_SHORTCIRCUIT_SERVER_QUERIES = import.meta.env.VITE_API_GATEWAY + '/shortcircuit';
diff --git a/src/services/study/study-config.ts b/src/services/study/study-config.ts
index 80894444db..a76e8c9678 100644
--- a/src/services/study/study-config.ts
+++ b/src/services/study/study-config.ts
@@ -13,7 +13,7 @@ import {
     SpreadsheetCollectionDto,
     SpreadsheetConfig,
 } from 'components/spreadsheet-view/types/spreadsheet.type';
-import { GlobalFilter } from '../../components/results/common/global-filter/global-filter-types';
+import { GlobalFilter } from '../../components/results/common/global-filter/global-filter.type';
 import { TableType, SortConfig } from '../../types/custom-aggrid-types';
 
 export function getNetworkVisualizationParameters(studyUuid: UUID): Promise<NetworkVisualizationParameters> {
diff --git a/src/services/study/voltage-init.ts b/src/services/study/voltage-init.ts
index a550a0a0a1..33639a8972 100644
--- a/src/services/study/voltage-init.ts
+++ b/src/services/study/voltage-init.ts
@@ -8,7 +8,7 @@
 import { getStudyUrl, getStudyUrlWithNodeUuidAndRootNetworkUuid } from './index';
 import type { UUID } from 'node:crypto';
 import { backendFetch, backendFetchJson, backendFetchText, VoltageInitStudyParameters } from '@gridsuite/commons-ui';
-import { ResultsQueryParams } from '../../components/results/common/global-filter/global-filter-types';
+import { ResultsQueryParams } from '../../components/results/common/global-filter/global-filter.type';
 
 export function startVoltageInit(
     studyUuid: UUID,