@gen3/core 0.10.44

package/dist/cjs/index.js

@@ -0,0 +1,2243 @@
+'use strict';
+
+var toolkit = require('@reduxjs/toolkit');
+var react = require('@reduxjs/toolkit/query/react');
+var React = require('react');
+var reactRedux = require('react-redux');
+var react$1 = require('@reduxjs/toolkit/dist/query/react');
+var cookiesNext = require('cookies-next');
+var query = require('@reduxjs/toolkit/query');
+var lodash = require('lodash');
+var Queue = require('queue');
+var jsonpathPlus = require('jsonpath-plus');
+var uuid = require('uuid');
+require('redux-persist');
+var reactCookie = require('react-cookie');
+var useSWR = require('swr');
+var flat = require('flat');
+var Papa = require('papaparse');
+
+const GEN3_COMMONS_NAME = process.env.GEN3_COMMONS_NAME || 'gen3';
+const GEN3_API = process.env.NEXT_PUBLIC_GEN3_API || '';
+const GEN3_DOMAIN = process.env.NEXT_PUBLIC_GEN3_DOMAIN || '';
+/**
+ *  Service Specific Constants
+ */ const GEN3_GUPPY_API = process.env.NEXT_PUBLIC_GEN3_GUPPY_API || `${GEN3_API}/guppy`;
+const GEN3_MDS_API = process.env.NEXT_PUBLIC_GEN3_MDS_API || `${GEN3_API}/mds`;
+const GEN3_DOWNLOADS_ENDPOINT = process.env.NEXT_PUBLIC_GEN3_DOWNLOADS_ENDPOINT || 'downloads';
+const GEN3_FENCE_API = process.env.NEXT_PUBLIC_GEN3_FENCE_API || GEN3_API;
+const GEN3_AI_SEARCH_API = process.env.NEXT_PUBLIC_GEN3_AI_SEARCH_API || `${GEN3_API}/ai-search`;
+const GEN3_AUTHZ_API = process.env.NEXT_PUBLIC_GEN3_AUTHZ_API || `${GEN3_API}/authz`;
+const GEN3_REDIRECT_URL = process.env.NEXT_PUBLIC_GEN3_REDIRECT_URL || GEN3_API;
+const GEN3_WORKSPACE_STATUS_API = process.env.NEXT_PUBLIC_GEN3_WORKSPACE_STATUS_API || `${GEN3_API}/lw-workspace`;
+const GEN3_SUBMISSION_API = process.env.NEXT_PUBLIC_GEN3_SUBMISSION_API || `${GEN3_API}/api/v0/submission`;
+const GEN3_WTS_API = process.env.NEXT_PUBLIC_GEN3_WTS_API || `${GEN3_API}/wts`;
+const GEN3_CROSSWALK_API = process.env.NEXT_PUBLIC_GEN3_CROSSWALK_API || `${GEN3_API}/mds`;
+exports.Accessibility = void 0;
+(function(Accessibility) {
+    Accessibility["ACCESSIBLE"] = "accessible";
+    Accessibility["UNACCESSIBLE"] = "unaccessible";
+    Accessibility["ALL"] = "all";
+})(exports.Accessibility || (exports.Accessibility = {}));
+const FILE_DELIMITERS = {
+    tsv: '\t',
+    csv: ','
+};
+
+// From here down is react-related code. If we wanted to create a UI-agnotic core,
+// we could need to move the following code and the provider into a new workspace,
+// such as core-react.
+/**
+ * The initial context is never used in practice. A little casting voodoo to satisfy TS.
+ *
+ * Note: Should the action type be AnyAction (from redux) or PayloadAction (from redux-toolkit)?
+ * If we are creating all of our actions through RTK, then PayloadAction might be the
+ * correct opinionated type.
+ */ const CoreContext = React.createContext(undefined);
+const useCoreSelector = reactRedux.createSelectorHook(CoreContext);
+const useCoreDispatch = reactRedux.createDispatchHook(CoreContext);
+const useCoreStore = reactRedux.createStoreHook(CoreContext);
+
+/**
+ * Creates a custom Redux Toolkit core API
+ * See: https://redux-toolkit.js.org/rtk-query/usage/customizing-create-api
+ * @returns: created core API.
+ */ const coreCreateApi = react.buildCreateApi(react.coreModule(), react.reactHooksModule({
+    useSelector: useCoreSelector,
+    useStore: useCoreStore,
+    useDispatch: useCoreDispatch
+}));
+
+/**
+ * Template for fence error response dict
+ * @returns: An error dict response from a RESTFUL API request
+ */ const buildFetchError = async (res, request)=>{
+    return {
+        url: res.url,
+        status: res.status,
+        statusText: res.statusText,
+        text: await res.text(),
+        request: request
+    };
+};
+/**
+ * Template for a standard fence request
+ * @returns: response data
+ */ const fetchFence = async ({ endpoint, headers, body = {}, method = 'GET', isJSON = true })=>{
+    const res = await fetch(`${GEN3_FENCE_API}${endpoint}`, {
+        method: method,
+        headers: headers,
+        body: 'POST' === method ? JSON.stringify(body) : null
+    });
+    if (res.ok) return {
+        data: isJSON ? await res.json() : await res.text(),
+        status: res.status
+    };
+    throw await buildFetchError(res, {
+        endpoint,
+        method,
+        headers,
+        body
+    });
+};
+
+const userAuthApi = coreCreateApi({
+    reducerPath: 'userAuthApi',
+    refetchOnMountOrArgChange: 1800,
+    refetchOnReconnect: true,
+    baseQuery: async ({ endpoint }, { getState })=>{
+        let results;
+        const csrfToken = selectCSRFToken(getState());
+        let accessToken = undefined;
+        if (process.env.NODE_ENV === 'development') {
+            accessToken = cookiesNext.getCookie('credentials_token');
+        }
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...csrfToken ? {
+                'X-CSRF-Token': csrfToken
+            } : {},
+            ...accessToken ? {
+                Authorization: `Bearer ${accessToken}`
+            } : {},
+            credentials: 'include'
+        };
+        try {
+            results = await fetchFence({
+                endpoint,
+                headers
+            });
+        } catch (e) {
+            /*
+        Because an "error" response is valid for the auth requests we don't want to
+        put the request in an error state, or it will attempt the request over and over again
+      */ return {
+                data: {}
+            };
+        }
+        return {
+            data: results
+        };
+    },
+    endpoints: (builder)=>({
+            fetchUserDetails: builder.query({
+                query: ()=>({
+                        endpoint: '/user/user'
+                    }),
+                transformResponse (response) {
+                    return {
+                        data: response.data,
+                        // TODO: check if this is the correct status code
+                        loginStatus: response.status === 200 && response.data?.username ? 'authenticated' : 'unauthenticated'
+                    };
+                }
+            }),
+            getCSRF: builder.query({
+                query: ()=>({
+                        endpoint: '/_status'
+                    }),
+                transformResponse: (response)=>{
+                    return {
+                        csrfToken: response?.data?.csrf ?? ''
+                    };
+                }
+            })
+        })
+});
+const EMPTY_USER = {
+    username: undefined
+};
+const { useFetchUserDetailsQuery, useLazyFetchUserDetailsQuery, useGetCSRFQuery } = userAuthApi;
+const userAuthApiMiddleware = userAuthApi.middleware;
+const userAuthApiReducerPath = userAuthApi.reducerPath;
+const userAuthApiReducer = userAuthApi.reducer;
+const selectUserDetailsFromState = userAuthApi.endpoints.fetchUserDetails.select();
+const selectUserDetails = toolkit.createSelector(selectUserDetailsFromState, (userDetails)=>userDetails?.data?.data ?? EMPTY_USER);
+const selectUserAuthStatus = toolkit.createSelector(selectUserDetailsFromState, (userLoginState)=>userLoginState.status === query.QueryStatus.pending ? 'pending' : userLoginState.status === query.QueryStatus.uninitialized ? 'not present' : userLoginState?.data?.loginStatus ?? 'unauthenticated');
+const selectCSRFTokenData = userAuthApi.endpoints.getCSRF.select();
+const passThroughTheState = (state)=>state.gen3Services;
+const selectCSRFToken = toolkit.createSelector([
+    selectCSRFTokenData,
+    passThroughTheState
+], (state)=>state?.data?.csrfToken);
+const selectHeadersWithCSRFToken = toolkit.createSelector([
+    selectCSRFToken,
+    passThroughTheState
+], (csrfToken)=>({
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...csrfToken && {
+            'X-CSRF-Token': csrfToken
+        }
+    }));
+
+/**
+ * Creates a base class core API for building other API endpoints on top of.
+ * @param reducerPath - The root key name that the other slices will be derived from
+ * @param baseQuery: - The template query which the slices will addon to
+ * @param endpoints - Base API endpoints that should exist in every slice
+ * @returns: The generated base API
+ */ const gen3Api = coreCreateApi({
+    reducerPath: 'gen3Services',
+    baseQuery: react$1.fetchBaseQuery({
+        baseUrl: `${GEN3_API}`,
+        prepareHeaders: (headers, { getState })=>{
+            const csrfToken = selectCSRFToken(getState());
+            headers.set('Content-Type', 'application/json');
+            let accessToken = undefined;
+            if (process.env.NODE_ENV === 'development') {
+                // NOTE: This cookie can only be accessed from the client side
+                // in development mode. Otherwise, the cookie is set as httpOnly
+                accessToken = cookiesNext.getCookie('credentials_token');
+            }
+            if (csrfToken) headers.set('X-CSRF-Token', csrfToken);
+            if (accessToken) headers.set('Authorization', `Bearer ${accessToken}`);
+            return headers;
+        }
+    }),
+    endpoints: ()=>({})
+});
+const gen3ServicesReducer = gen3Api.reducer;
+const gen3ServicesReducerMiddleware = gen3Api.middleware;
+
+/**
+ * Creates a fence API endpoint for handling login processes
+ * @param endpoints - defined endpoint query for logging in
+ * @returns: The generated fence login API slice
+ */ const loginProvidersApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getLoginProviders: builder.query({
+                query: ()=>`${GEN3_FENCE_API}/user/login`
+            })
+        })
+});
+const { useGetLoginProvidersQuery } = loginProvidersApi;
+/**
+ * Logout from fence
+ */ const logoutFence = async (redirect = '/')=>await fetchFence({
+        endpoint: `${GEN3_FENCE_API}/user/logout?next=${GEN3_REDIRECT_URL}${redirect}`,
+        method: 'GET'
+    });
+
+// extending the gen3API to add a tag to the endpoints
+const credentialsWithTags$1 = gen3Api.enhanceEndpoints({
+    addTagTypes: [
+        'Credentials'
+    ]
+});
+/**
+ * Adds a credentialsApi into the base gen3Api
+ * @endpoints Includes get, add, and remove credential operations
+ *  @see https://github.com/uc-cdis/fence/blob/master/openapis/swagger.yaml#L972-L1033
+ *  @param getCredentials - List all the API keys for the current user
+ *  @param addNewCredential - Get a new API key for the current user
+ *  @param removeCredential - Delete API access key with given ID for current user
+ * @returns: A fence credential API for manipulating user credentials
+ */ const credentialsApi = credentialsWithTags$1.injectEndpoints({
+    endpoints: (builder)=>({
+            getCredentials: builder.query({
+                query: ()=>`${GEN3_FENCE_API}/user/credentials/api`,
+                transformResponse: (response)=>response['jtis'],
+                // "jtis", which is an array of API keys
+                // no need to transform the response, since the API returns the correct format
+                providesTags: [
+                    'Credentials'
+                ]
+            }),
+            addNewCredential: builder.mutation({
+                query: (csrfToken)=>({
+                        url: `${GEN3_FENCE_API}/user/credentials/api`,
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-csrf-token': csrfToken
+                        },
+                        body: {
+                            scope: [
+                                'user',
+                                'data'
+                            ]
+                        }
+                    }),
+                invalidatesTags: [
+                    'Credentials'
+                ]
+            }),
+            removeCredential: builder.mutation({
+                query: ({ csrfToken, id })=>({
+                        url: `${GEN3_FENCE_API}/user/credentials/api/${id}`,
+                        method: 'DELETE',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...csrfToken && {
+                                'x-csrf-token': csrfToken
+                            }
+                        }
+                    }),
+                invalidatesTags: [
+                    'Credentials'
+                ]
+            }),
+            authorizeFromCredentials: builder.mutation({
+                query: (params)=>({
+                        url: `${GEN3_FENCE_API}/user/credentials/api/access_token`,
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: {
+                            api_key: params.api_key,
+                            key_id: params.key_id
+                        }
+                    })
+            })
+        })
+});
+const { useGetCredentialsQuery, useAddNewCredentialMutation, useRemoveCredentialMutation, useAuthorizeFromCredentialsMutation } = credentialsApi;
+
+// extending the gen3API to add a tag to the endpoints
+const credentialsWithTags = gen3Api.enhanceEndpoints({
+    addTagTypes: [
+        'fenceJWT'
+    ]
+});
+/**
+ * A fence API for getting the public keys which can be used to validate
+ * JWTs issued and signed by fence
+ * @returns: Fence public keys
+ */ const jwtApi = credentialsWithTags.injectEndpoints({
+    endpoints: (builder)=>({
+            getJWKKeys: builder.query({
+                query: ()=>'user/jwt/keys',
+                providesTags: [
+                    'fenceJWT'
+                ]
+            })
+        })
+});
+const { useGetJWKKeysQuery } = jwtApi;
+
+const usePrevious = (value)=>{
+    const ref = React.useRef();
+    React.useEffect(()=>{
+        ref.current = value;
+    });
+    return ref.current;
+};
+const createUseCoreDataHook = (fetchDataActionCreator, dataSelector)=>{
+    return (...params)=>{
+        const coreDispatch = useCoreDispatch();
+        const { data, status, error } = useCoreSelector(dataSelector);
+        const action = fetchDataActionCreator(...params);
+        const prevParams = usePrevious(params);
+        React.useEffect(()=>{
+            if (status === 'uninitialized' || !lodash.isEqual(prevParams, params)) {
+                // createDispatchHook types forces the input to AnyAction, which is
+                // not compatible with thunk actions. hence, the `as any` cast. ;(
+                coreDispatch(action); // eslint-disable-line
+            }
+        }, [
+            status,
+            coreDispatch,
+            action,
+            params,
+            prevParams
+        ]);
+        return {
+            data,
+            error,
+            isUninitialized: status === 'uninitialized',
+            isFetching: status === 'pending',
+            isSuccess: status === 'fulfilled',
+            isError: status === 'rejected'
+        };
+    };
+};
+
+/**
+ * Creates an async thunk for fetching user permissions details from fence
+ * @see https://redux-toolkit.js.org/api/createAsyncThunk
+ * @returns: A fence response dict containing user details
+ */ const fetchUserState = toolkit.createAsyncThunk('fence/user/user', async (_, meta)=>{
+    // Get an access token from a cookie if in development mode
+    const csrfToken = selectCSRFToken(meta.getState());
+    let accessToken = undefined;
+    if (process.env.NODE_ENV === 'development') {
+        accessToken = cookiesNext.getCookie('credentials_token');
+    }
+    return await fetchFence({
+        endpoint: '/user/user',
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...csrfToken ? {
+                'X-CSRF-Token': csrfToken
+            } : {},
+            credentials: 'include',
+            ...accessToken ? {
+                Authorization: `Bearer ${accessToken}`
+            } : {}
+        }
+    });
+});
+const isAuthenticated = (loginStatus)=>loginStatus === 'authenticated';
+const isPending = (loginStatus)=>loginStatus === 'pending';
+const initialState$3 = {
+    status: 'uninitialized',
+    loginStatus: 'unauthenticated',
+    error: undefined
+};
+/**
+ * Wraps a slice on top of fetchUserState async thunk to keep track of
+ * query state. authenticated/not-authenticated vs. ejected/fulfilled/pending
+ * @returns: status messages wrapped around fetchUserState response dict
+ */ const slice$3 = toolkit.createSlice({
+    name: 'fence/user',
+    initialState: initialState$3,
+    reducers: {
+        resetUserState: ()=>initialState$3
+    },
+    extraReducers: (builder)=>{
+        builder.addCase(fetchUserState.fulfilled, (_, action)=>{
+            const response = action.payload;
+            if (response.status !== 200) {
+                return {
+                    status: 'rejected',
+                    loginStatus: 'unauthenticated'
+                };
+            }
+            return {
+                data: {
+                    ...response.data
+                },
+                status: 'fulfilled',
+                loginStatus: 'authenticated'
+            };
+        }).addCase(fetchUserState.pending, ()=>{
+            return {
+                status: 'pending',
+                loginStatus: 'unauthenticated'
+            };
+        }).addCase(fetchUserState.rejected, ()=>{
+            return {
+                status: 'rejected',
+                loginStatus: 'unauthenticated'
+            };
+        });
+    }
+});
+const userReducer = slice$3.reducer;
+const { resetUserState } = slice$3.actions;
+const selectUserData = (state)=>{
+    return state.user;
+};
+const selectUser = (state)=>state.user;
+const selectUserLoginStatus = (state)=>state.user.loginStatus;
+const useUser = createUseCoreDataHook(fetchUserState, selectUserData);
+const useIsUserLoggedIn = ()=>{
+    return useCoreSelector((state)=>isAuthenticated(selectUserLoginStatus(state)));
+};
+/**
+ * Hook to return get the authenticated state of the user and if logged in,
+ * the user's profile and access api.
+ * Note that if fetchUserState gets called, the user's session is renewed.
+ */ const useUserAuth = (renew = false)=>{
+    const coreDispatch = useCoreDispatch();
+    const { data, status, loginStatus, error } = useCoreSelector(selectUserData);
+    React.useEffect(()=>{
+        if (status === 'uninitialized' || renew) {
+            // TODO: need to determine what other states require dispatch
+            coreDispatch(fetchUserState());
+        }
+    }, [
+        status,
+        coreDispatch,
+        renew
+    ]);
+    return {
+        data: data,
+        error,
+        loginStatus,
+        isUninitialized: status === 'uninitialized',
+        isFetching: status === 'pending',
+        isSuccess: status === 'fulfilled',
+        isError: status === 'rejected'
+    };
+};
+
+/**
+ *  @description Creates a externalLoginApi for listing the configured identity providers
+ *  in workspace token service. Includes user token expiration time.
+ *  @see https://github.com/uc-cdis/workspace-token-service/tree/master
+ */ const externalLoginApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getExternalLogins: builder.query({
+                query: ()=>({
+                        url: `${GEN3_WTS_API}/external_oidc/`
+                    })
+            }),
+            isExternalConnected: builder.query({
+                query: (idp)=>({
+                        url: `${GEN3_WTS_API}/oauth2/connected?idp=${idp}`
+                    }),
+                transformResponse: ()=>{
+                    return true; // if success then connected is true
+                }
+            })
+        })
+});
+const { useGetExternalLoginsQuery, useLazyGetExternalLoginsQuery, useLazyIsExternalConnectedQuery, useIsExternalConnectedQuery } = externalLoginApi;
+
+// type guard functions
+const isHistogramRangeData = (key)=>{
+    return Array.isArray(key) && key.length === 2 && key.every((item)=>typeof item === 'number');
+};
+const isJSONObject = (data)=>{
+    return typeof data === 'object' && data !== null && !Array.isArray(data);
+};
+const isJSONValue = (data)=>{
+    return typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean' || Array.isArray(data) && data.every(isJSONValue) || isJSONObject(data);
+};
+const isJSONValueArray = (data)=>{
+    return Array.isArray(data) && data.every(isJSONValue);
+};
+const isValidObject = (input)=>typeof input === 'object' && input !== null;
+const isHistogramData = (data)=>{
+    return isValidObject(data) && 'key' in data && 'count' in data;
+};
+const isHistogramDataArray = (input)=>{
+    if (!isValidObject(input) || !Array.isArray(input.histogram)) {
+        return false;
+    }
+    return input.histogram.every(isHistogramData);
+};
+const isHistogramDataCollection = (obj)=>{
+    return isValidObject(obj) && 'histogram' in obj && isHistogramData(obj.histogram);
+};
+// Type guard function for GuppyAggregationData interface
+const isGuppyAggregationData = (obj)=>{
+    if (!isValidObject(obj)) return false;
+    for(const key in obj){
+        if (!isHistogramDataCollection(obj[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+const isHistogramDataAnEnum = (data)=>{
+    return typeof data === 'object' && data !== null && 'key' in data && 'count' in data && typeof data.key === 'string' && typeof data.count === 'number';
+};
+const isHistogramDataAArray = (data)=>{
+    return Array.isArray(data) && data.every(isHistogramData);
+};
+const isHistogramDataArrayAnEnum = (data)=>{
+    return Array.isArray(data) && data.every(isHistogramDataAnEnum);
+};
+const isHistogramDataArrayARange = (data)=>{
+    return Array.isArray(data) && data.every((item)=>isHistogramRangeData(item.key));
+};
+/**
+ * Type predicate to narrow an unknown error to `FetchBaseQueryError`
+ */ function isFetchBaseQueryError(error) {
+    return typeof error === 'object' && error != null && 'status' in error;
+}
+/**
+ * Type predicate to narrow an unknown error to an object with a string 'message' property
+ */ function isErrorWithMessage(error) {
+    return typeof error === 'object' && error != null && 'message' in error && typeof error.message === 'string';
+}
+/**
+ * Type predicate to narrow an unknown error to an object with a string 'message' property
+ */ function isFetchParseError(error) {
+    return typeof error === 'object' && error != null && 'originalStatus' in error && 'status' in error && error['status'] === 'PARSING_ERROR';
+}
+
+/**
+ * A registry for the Gen3 Apps.
+ */ const REGISTRY = {};
+const registerGen3App = (id, gen3App)=>{
+    REGISTRY[id] = gen3App;
+};
+const lookupGen3App = (id)=>{
+    return REGISTRY[id];
+};
+
+const initialState$2 = {
+    gen3Apps: {}
+};
+const slice$2 = toolkit.createSlice({
+    name: 'gen3Apps',
+    initialState: initialState$2,
+    reducers: {
+        addGen3AppMetadata: (state, action)=>{
+            const { id, requiredEntityTypes } = action.payload;
+            state.gen3Apps[id] = {
+                ...action.payload,
+                // need to turn a ReadonlyArray into a mutable array for immer's WritableDraft
+                requiredEntityTypes: [
+                    ...requiredEntityTypes
+                ]
+            };
+        }
+    }
+});
+const gen3AppReducer = slice$2.reducer;
+const { addGen3AppMetadata } = slice$2.actions;
+const selectGen3AppMetadataById = (state, appId)=>state.gen3Apps.gen3Apps[appId];
+const selectGen3AppById = (appId)=>lookupGen3App(appId); // TODO: memoize this selector
+
+const initialState$1 = {};
+// TODO: document what this does
+const slice$1 = toolkit.createSlice({
+    name: 'drsResolver',
+    initialState: initialState$1,
+    reducers: {
+        setDRSHostnames: (_state, action)=>{
+            return action.payload;
+        }
+    }
+});
+const drsHostnamesReducer = slice$1.reducer;
+const { setDRSHostnames } = slice$1.actions;
+
+exports.Modals = void 0;
+(function(Modals) {
+    Modals["FirstTimeModal"] = "FirstTimeModal";
+    Modals["SessionExpireModal"] = "SessionExpireModal";
+    Modals["NoAccessModal"] = "NoAccessModal";
+    Modals["CreateCredentialsAPIKeyModal"] = "CreateCredentialsAPIKeyModal";
+    Modals["GeneralErrorModal"] = "GeneralErrorModal";
+})(exports.Modals || (exports.Modals = {}));
+const initialState = {
+    currentModal: null
+};
+//Creates a modal slice for tracking showModal and hideModal state.
+const slice = toolkit.createSlice({
+    name: 'modals',
+    initialState,
+    reducers: {
+        showModal: (state, action)=>{
+            state.currentModal = action.payload.modal;
+            state.message = action.payload.message;
+            return state;
+        },
+        hideModal: (state)=>{
+            state.currentModal = null;
+            return state;
+        }
+    }
+});
+const modalReducer = slice.reducer;
+const { showModal, hideModal } = slice.actions;
+const selectCurrentModal = (state)=>state.modals.currentModal;
+const selectCurrentMessage = (state)=>state.modals.message;
+
+const initialCohortState = {
+    cohort: {
+        id: 'default',
+        name: 'Filters',
+        filters: {},
+        modified_datetime: new Date().toISOString()
+    }
+};
+// TODO: start using this adapter
+/*
+const cohortsAdapter = createEntityAdapter<Cohort>({
+  sortComparer: (a, b) => {
+    if (a.modified_datetime <= b.modified_datetime) return 1;
+    else return -1;
+  },
+});
+*/ /**
+ * Redux slice for cohort filters
+ */ const cohortSlice = toolkit.createSlice({
+    name: 'cohort',
+    initialState: initialCohortState,
+    reducers: {
+        // adds a filter to the cohort filter set at the given index
+        updateCohortFilter: (state, action)=>{
+            const { index, field, filter } = action.payload;
+            return {
+                cohort: {
+                    ...state.cohort,
+                    filters: {
+                        ...state.cohort.filters,
+                        [index]: {
+                            mode: state.cohort.filters?.[index]?.mode ?? 'and',
+                            root: {
+                                ...state.cohort.filters?.[index]?.root ?? {},
+                                [field]: filter
+                            }
+                        }
+                    }
+                }
+            };
+        },
+        // removes a filter to the cohort filter set at the given index
+        removeCohortFilter: (state, action)=>{
+            const { index, field } = action.payload;
+            const filters = state.cohort?.filters?.[index]?.root;
+            if (!filters) {
+                return;
+            }
+            const { [field]: _a, ...updated } = filters;
+            return {
+                cohort: {
+                    ...state.cohort,
+                    filters: {
+                        ...state.cohort.filters,
+                        [index]: {
+                            mode: state.cohort.filters[index].mode,
+                            root: updated
+                        }
+                    }
+                }
+            };
+        },
+        // removes all filters from the cohort filter set at the given index
+        clearCohortFilters: (state, action)=>{
+            const { index } = action.payload;
+            return {
+                cohort: {
+                    ...state.cohort,
+                    filters: {
+                        ...state.cohort.filters,
+                        [index]: {
+                            // empty filter set
+                            mode: 'and',
+                            root: {}
+                        }
+                    }
+                }
+            };
+        }
+    },
+    extraReducers: {}
+});
+// Filter actions: addFilter, removeFilter, updateFilter
+const { updateCohortFilter, removeCohortFilter, clearCohortFilters } = cohortSlice.actions;
+const selectCohortFilters = (state)=>state.cohorts.cohort.filters;
+const selectCurrentCohortId = (state)=>state.cohorts.cohort.id;
+const selectCurrentCohort = (state)=>state.cohorts.cohort;
+const selectCurrentCohortName = (state)=>state.cohorts.cohort.name;
+/**
+ * Select a filter by its name from the current cohort. If the filter is not found
+ * returns undefined.
+ * @param state - Core
+ * @param index which cohort index to select from
+ * @param name name of the filter to select
+ */ const selectIndexedFilterByName = (state, index, name)=>{
+    return state.cohorts.cohort.filters[index]?.root[name];
+};
+const EmptyFilterSet = {
+    mode: 'and',
+    root: {}
+};
+/**
+ * Select a filter from the index.
+ * returns undefined.
+ * @param state - Core
+ * @param index which cohort index to select from
+ */ const selectIndexFilters = (state, index)=>{
+    return state.cohorts.cohort.filters?.[index] ?? EmptyFilterSet; // TODO: check if this is undefined
+};
+const cohortReducer = cohortSlice.reducer;
+
+/**
+ * Creates a base class core API for guppy API calls.
+ * @returns: guppy core API with guppyAPIFetch base query
+ */ const guppyApi = coreCreateApi({
+    reducerPath: 'guppy',
+    // TODO: refactor to use fetchBaseQuery
+    baseQuery: async (query, api)=>{
+        const csrfToken = selectCSRFToken(api.getState());
+        let accessToken = undefined;
+        if (process.env.NODE_ENV === 'development') {
+            // NOTE: This cookie can only be accessed from the client side
+            // in development mode. Otherwise, the cookie is set as httpOnly
+            accessToken = cookiesNext.getCookie('credentials_token');
+        }
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*',
+            ...csrfToken && {
+                'X-CSRF-Token': csrfToken
+            },
+            ...accessToken && {
+                Authorization: `Bearer ${accessToken}`
+            }
+        };
+        try {
+            const response = await fetch(`${GEN3_GUPPY_API}/graphql`, {
+                headers: headers,
+                method: 'POST',
+                body: JSON.stringify(query)
+            });
+            return {
+                data: await response.json()
+            };
+        } catch (e) {
+            if (e instanceof Error) return {
+                error: e.message
+            };
+            return {
+                error: e
+            };
+        }
+    },
+    endpoints: ()=>({})
+});
+const guppyAPISliceMiddleware = guppyApi.middleware;
+const guppyApiSliceReducerPath = guppyApi.reducerPath;
+const guppyApiReducer = guppyApi.reducer;
+
+const rootReducer = toolkit.combineReducers({
+    gen3Services: gen3ServicesReducer,
+    user: userReducer,
+    gen3Apps: gen3AppReducer,
+    drsHostnames: drsHostnamesReducer,
+    modals: modalReducer,
+    cohorts: cohortReducer,
+    [guppyApiSliceReducerPath]: guppyApiReducer,
+    [userAuthApiReducerPath]: userAuthApiReducer
+});
+
+const coreStore = toolkit.configureStore({
+    reducer: rootReducer,
+    middleware: (getDefaultMiddleware)=>getDefaultMiddleware().concat(gen3ServicesReducerMiddleware, guppyAPISliceMiddleware, userAuthApiMiddleware)
+});
+query.setupListeners(coreStore.dispatch);
+
+const CoreProvider = ({ children })=>{
+    return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
+        store: coreStore,
+        context: CoreContext
+    }, children);
+};
+
+/**
+ * Creates the authzApi for checking arborist permissions for a selected user
+ * @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/arborist/master/docs/openapi.yaml#/auth/get_auth_mapping
+ * @see https://github.com/uc-cdis/arborist/blob/master/docs/relationships.simplified.png
+ * @returns: An arborist response dict of user permissions {method, service} for each resource path.
+ */ const authzApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getAuthzMappings: builder.query({
+                query: ()=>`${GEN3_AUTHZ_API}/mapping`
+            })
+        })
+});
+const { useGetAuthzMappingsQuery } = authzApi;
+const selectAuthzMapping = authzApi.endpoints.getAuthzMappings.select();
+const selectAuthzMappingData = toolkit.createSelector(selectAuthzMapping, (authzMapping)=>authzMapping?.data ?? {
+        mappings: []
+    });
+
+const HasEnoughData = (data, keys, limit)=>{
+    const numEmptyKeys = keys.filter((k)=>Object.hasOwn(data, k) && typeof data[k] === 'string' && data[k].trim() === '').length;
+    return numEmptyKeys < limit;
+};
+/**
+ * Defines metadataApi service using a base URL and expected endpoints. Derived from gen3Api core API.
+ *
+ * @param endpoints - Defines endpoints used in discovery page
+ *  @param getAggMDS - Queries aggregate metadata service
+ *    @see https://github.com/uc-cdis/metadata-service/blob/master/docs/agg_mds.md
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_metadata_aggregate_metadata_get
+ *  @param getMDS - Queries normal metadata service
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Query/search_metadata_metadata_get
+ *  @param getIndexAggMDS - queries the Aggregate Metadata service and returns all common passed in indexKeys
+ *  @param getTags - Probably refering to Aggregate metadata service summary statistics query
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_tags_aggregate_tags_get
+ *  @param getData - Looks like a duplicate of getMDS handler. unused in ./frontend package
+ *  @param getCrosswalkData - Maps ids from one source to another
+ * @returns: A guppy download API for fetching bulk metadata
+ */ const metadataApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getAggMDS: builder.query({
+                query: ({ offset, pageSize })=>{
+                    return `${GEN3_MDS_API}/aggregate/metadata?flatten=true&pagination=true&offset=${offset}&limit=${pageSize}`;
+                },
+                transformResponse: (response, _meta, params)=>{
+                    return {
+                        data: response.results.map((x)=>{
+                            const objValues = Object.values(x);
+                            const firstValue = objValues ? objValues.at(0) : undefined;
+                            return firstValue ? firstValue[params.studyField] : undefined;
+                        }),
+                        hits: response.pagination.hits
+                    };
+                }
+            }),
+            getIndexAggMDS: builder.query({
+                query: ({ pageSize })=>{
+                    return `${GEN3_MDS_API}/aggregate/metadata?limit=${pageSize}`;
+                },
+                transformResponse: (response, _meta, params)=>{
+                    const dataFromIndexes = params.indexKeys.reduce((acc, key)=>{
+                        if (response[key]) {
+                            acc.push(...response[key]);
+                        }
+                        return acc;
+                    }, []);
+                    return {
+                        data: dataFromIndexes.map((x)=>{
+                            const objValues = Object.values(x);
+                            const objIds = Object.keys(x);
+                            let firstValue = objValues ? objValues.at(0) : undefined;
+                            if (params?.filterEmpty) {
+                                // remove any data that has < limit if defined
+                                if (firstValue && !HasEnoughData(firstValue[params.studyField], params.filterEmpty.keys, params.filterEmpty.limit)) firstValue = undefined;
+                            }
+                            return firstValue ? {
+                                gen3MDSGUID: objIds.at(0),
+                                ...firstValue[params.studyField]
+                            } : undefined;
+                        }).filter((x)=>x !== undefined),
+                        hits: dataFromIndexes.length
+                    };
+                }
+            }),
+            getMDS: builder.query({
+                query: ({ guidType, offset, pageSize })=>{
+                    return `${GEN3_MDS_API}/metadata?data=True&_guid_type=${guidType}&limit=${pageSize}&offset=${offset}`;
+                },
+                transformResponse: (response, _meta)=>{
+                    return {
+                        data: Object.keys(response).map((guid)=>response[guid]),
+                        hits: Object.keys(response).length
+                    };
+                }
+            }),
+            getTags: builder.query({
+                query: ()=>'tags'
+            }),
+            getData: builder.query({
+                query: (params)=>({
+                        url: `metadata?${params}`
+                    })
+            }),
+            // TODO: Move this to own slice
+            getCrosswalkData: builder.query({
+                queryFn: async (arg, _queryApi, _extraOptions, fetchWithBQ)=>{
+                    const queryMultiple = async ()=>{
+                        let result = [];
+                        const queue = Queue({
+                            concurrency: 15
+                        });
+                        for (const id of arg.ids){
+                            queue.push(async (callback)=>{
+                                const response = await fetchWithBQ({
+                                    url: `${GEN3_CROSSWALK_API}/metadata/${id}`
+                                });
+                                if (response.error) {
+                                    return {
+                                        error: response.error
+                                    };
+                                }
+                                const toData = arg.toPaths.reduce((acc, path)=>{
+                                    acc[path.id] = jsonpathPlus.JSONPath({
+                                        json: response.data,
+                                        path: `$.[${path.dataPath}]`,
+                                        resultType: 'value'
+                                    })?.[0] ?? 'n/a';
+                                    return acc;
+                                }, {});
+                                result = [
+                                    ...result,
+                                    {
+                                        from: id,
+                                        to: toData
+                                    }
+                                ];
+                                callback && callback();
+                                return result;
+                            });
+                        }
+                        return new Promise((resolve, reject)=>{
+                            queue.start((err)=>{
+                                if (err) {
+                                    reject(err);
+                                } else {
+                                    resolve(result);
+                                }
+                            });
+                        });
+                    };
+                    const result = await queryMultiple();
+                    return {
+                        data: result
+                    };
+                }
+            })
+        })
+});
+const { useGetAggMDSQuery, useGetMDSQuery, useGetTagsQuery, useGetDataQuery, useGetCrosswalkDataQuery, useLazyGetCrosswalkDataQuery, useGetIndexAggMDSQuery } = metadataApi;
+
+// using a random uuid v4 as the namespace
+const GEN3_APP_NAMESPACE = '7bfaa818-c69c-457e-8d87-413cf60c25f0';
+const getGen3AppId = (name, version)=>{
+    const nameVersion = `${name}::${version}`;
+    return uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
+};
+/**
+ *  TODO: can't tell what anything in this directory is doing.
+ */ const createGen3App = ({ App, name, version, requiredEntityTypes })=>{
+    // create a stable id for this app
+    const nameVersion = `${name}::${version}`;
+    const id = uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
+    // need to create store and provider.
+    // return a component representing this app
+    // if component gets added to a list, then the list can be iterated in index.js and each provider component can be added
+    // a route can be setup for the app
+    // need to register its name, category, path, data requirements
+    // this will be used to build page3
+    // click app link
+    const store = toolkit.configureStore({
+        // TODO allow user to pass in a reducer in CreateGen3AppOptions?
+        reducer: (state)=>state,
+        devTools: {
+            name: `${nameVersion}::${id}`
+        }
+    });
+    const Gen3AppWrapper = ()=>{
+        React.useEffect(()=>{
+            document.title = `GEN3 - ${name}`;
+        });
+        return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
+            store: store
+        }, /*#__PURE__*/ React.createElement(reactCookie.CookiesProvider, null, /*#__PURE__*/ React.createElement(App, null)));
+    };
+    // add the app to the store
+    coreStore.dispatch(addGen3AppMetadata({
+        id,
+        name,
+        version,
+        requiredEntityTypes
+    }));
+    registerGen3App(id, Gen3AppWrapper);
+    return Gen3AppWrapper;
+};
+
+const graphQLWithTags = gen3Api.enhanceEndpoints({
+    addTagTypes: [
+        'graphQL'
+    ]
+});
+/**
+ * Creates a graphQLAPI for graphql queries to elasticsearch indices via guppy
+ * @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md
+ * @param query - Resolver function which configures the graphql query with graphQLParams argument
+ * @returns: A guppy search API for fetching metadata
+ */ const graphQLAPI = graphQLWithTags.injectEndpoints({
+    endpoints: (builder)=>({
+            graphQL: builder.query({
+                query: (graphQLParams)=>({
+                        url: `${GEN3_GUPPY_API}/graphql`,
+                        method: 'POST',
+                        credentials: 'include',
+                        body: JSON.stringify(graphQLParams)
+                    })
+            })
+        })
+});
+const { useGraphQLQuery } = graphQLAPI;
+
+const isOperationWithField = (operation)=>{
+    return operation?.field !== undefined;
+};
+const extractFilterValue = (op)=>{
+    const valueExtractorHandler = new ValueExtractorHandler();
+    return handleOperation(valueExtractorHandler, op);
+};
+const extractEnumFilterValue = (op)=>{
+    const enumValueExtractorHandler = new EnumValueExtractorHandler();
+    const results = handleOperation(enumValueExtractorHandler, op);
+    return results ?? [];
+};
+const assertNever = (x)=>{
+    throw Error(`Exhaustive comparison did not handle: ${x}`);
+};
+const handleOperation = (handler, op)=>{
+    switch(op.operator){
+        case '=':
+            return handler.handleEquals(op);
+        case '!=':
+            return handler.handleNotEquals(op);
+        case '<':
+            return handler.handleLessThan(op);
+        case '<=':
+            return handler.handleLessThanOrEquals(op);
+        case '>':
+            return handler.handleGreaterThan(op);
+        case '>=':
+            return handler.handleGreaterThanOrEquals(op);
+        case 'and':
+            return handler.handleIntersection(op);
+        case 'or':
+            return handler.handleUnion(op);
+        case 'nested':
+            return handler.handleNestedFilter(op);
+        case 'in':
+            return handler.handleIncludes(op);
+        case 'excludeifany':
+            return handler.handleExcludeIfAny(op);
+        case 'excludes':
+            return handler.handleExcludes(op);
+        default:
+            return assertNever(op);
+    }
+};
+/**
+ * Return true if a FilterSet's root value is an empty object
+ * @param fs - FilterSet to test
+ */ const isFilterEmpty = (fs)=>lodash.isEqual({}, fs);
+class ToGqlHandler {
+    constructor(){
+        this.handleEquals = (op)=>({
+                '=': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleNotEquals = (op)=>({
+                '!=': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleLessThan = (op)=>({
+                '<': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleLessThanOrEquals = (op)=>({
+                '<=': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleGreaterThan = (op)=>({
+                '>': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleGreaterThanOrEquals = (op)=>({
+                '>=': {
+                    [op.field]: op.operand
+                }
+            });
+        this.handleIncludes = (op)=>({
+                in: {
+                    [op.field]: op.operands
+                }
+            });
+        this.handleExcludes = (op)=>({
+                exclude: {
+                    [op.field]: op.operands
+                }
+            });
+        this.handleExcludeIfAny = (op)=>({
+                excludeifany: {
+                    [op.field]: op.operands
+                }
+            });
+        this.handleIntersection = (op)=>({
+                and: op.operands.map((x)=>convertFilterToGqlFilter(x))
+            });
+        this.handleUnion = (op)=>({
+                or: op.operands.map((x)=>convertFilterToGqlFilter(x))
+            });
+        this.handleNestedFilter = (op)=>{
+            const child = convertFilterToGqlFilter(op.operand);
+            return {
+                nested: {
+                    path: op.path,
+                    ...child
+                }
+            };
+        };
+    }
+}
+const convertFilterToGqlFilter = (filter)=>{
+    const handler = new ToGqlHandler();
+    return handleOperation(handler, filter);
+};
+const convertFilterSetToGqlFilter = (fs, toplevelOp = 'and')=>{
+    const fsKeys = Object.keys(fs.root);
+    // if no keys return undefined
+    if (fsKeys.length === 0) return {
+        and: []
+    };
+    return toplevelOp === 'and' ? {
+        and: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
+    } : {
+        or: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
+    };
+};
+/**
+ * Extract the operand values, if operands themselves have values,  otherwise undefined.
+ */ class ValueExtractorHandler {
+    constructor(){
+        this.handleEquals = (op)=>op.operand;
+        this.handleNotEquals = (op)=>op.operand;
+        this.handleIncludes = (op)=>op.operands;
+        this.handleExcludes = (op)=>op.operands;
+        this.handleExcludeIfAny = (op)=>op.operands;
+        this.handleGreaterThanOrEquals = (op)=>op.operand;
+        this.handleGreaterThan = (op)=>op.operand;
+        this.handleLessThan = (op)=>op.operand;
+        this.handleLessThanOrEquals = (op)=>op.operand;
+        this.handleIntersection = (_)=>undefined;
+        this.handleUnion = (_)=>undefined;
+        this.handleNestedFilter = (_)=>undefined;
+    }
+}
+/**
+ * Extract the operand values, if operands themselves have values,  otherwise undefined.
+ */ class EnumValueExtractorHandler {
+    constructor(){
+        this.handleEquals = (_)=>undefined;
+        this.handleNotEquals = (_)=>undefined;
+        this.handleIncludes = (op)=>op.operands;
+        this.handleExcludes = (op)=>op.operands;
+        this.handleExcludeIfAny = (op)=>op.operands;
+        this.handleGreaterThanOrEquals = (_)=>undefined;
+        this.handleGreaterThan = (_)=>undefined;
+        this.handleLessThan = (_)=>undefined;
+        this.handleLessThanOrEquals = (_)=>undefined;
+        this.handleIntersection = (_)=>undefined;
+        this.handleUnion = (_)=>undefined;
+        this.handleNestedFilter = (op)=>{
+            return extractEnumFilterValue(op.operand);
+        };
+    }
+}
+
+const FieldNameOverrides = {};
+const COMMON_PREPOSITIONS = [
+    'a',
+    'an',
+    'and',
+    'at',
+    'but',
+    'by',
+    'for',
+    'in',
+    'is',
+    'nor',
+    'of',
+    'on',
+    'or',
+    'out',
+    'so',
+    'the',
+    'to',
+    'up',
+    'yet'
+];
+const capitalize = (s)=>s.length > 0 ? s[0].toUpperCase() + s.slice(1) : '';
+const trimFirstFieldNameToTitle = (fieldName, trim = false)=>{
+    if (trim) {
+        const source = fieldName.slice(fieldName.indexOf('.') + 1);
+        return fieldNameToTitle(source ? source : fieldName, 0);
+    }
+    return fieldNameToTitle(fieldName);
+};
+/**
+ * Converts a filter name to a title,
+ * For example files.input.experimental_strategy will get converted to Experimental Strategy
+ * if sections == 2 then the output would be Input Experimental Strategy
+ * @param fieldName input filter expected to be: string.firstpart_secondpart
+ * @param sections number of "sections" string.string.string to got back from the end of the field
+ */ const fieldNameToTitle = (fieldName, sections = 1)=>{
+    if (fieldName in FieldNameOverrides) {
+        return FieldNameOverrides[fieldName];
+    }
+    if (fieldName === undefined) return 'No Title';
+    return fieldName.split('.').slice(-sections).map((s)=>s.split('_')).flat().map((word)=>COMMON_PREPOSITIONS.includes(word) ? word : capitalize(word)).join(' ');
+};
+/**
+ * Extracts the index name from the field name
+ * @param fieldName
+ */ const extractIndexFromFullFieldName = (fieldName)=>fieldName.split('.')[0];
+/**
+ * prepend the index name to the field name
+ */ const prependIndexToFieldName = (fieldName, index)=>`${index}.${fieldName}`;
+/**
+ * extract the field name from the index.field name
+ */ const extractFieldNameFromFullFieldName = (fieldName)=>fieldName.split('.').slice(1).join('.');
+/**
+ * extract the field name and the index from the index.field name returning as a tuple
+ */ const extractIndexAndFieldNameFromFullFieldName = (fieldName)=>{
+    const [index, ...rest] = fieldName.split('.');
+    return [
+        index,
+        rest.join('.')
+    ];
+};
+
+const statusEndpoint = '/_status';
+const processHistogramResponse = (data)=>{
+    const pathData = jsonpathPlus.JSONPath({
+        json: data,
+        path: '$..histogram',
+        resultType: 'all'
+    });
+    const results = pathData.reduce((acc, element)=>{
+        const key = element.pointer.slice(1).replace(/\/histogram/g, '').replace(/\//g, '.');
+        return {
+            ...acc,
+            [key]: element.value
+        };
+    }, {});
+    return results;
+};
+const fetchJson = async (url)=>{
+    const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Content-type': 'application/json'
+        }
+    });
+    if (!res.ok) throw new Error('An error occurred while fetching the data.');
+    return await res.json();
+};
+const useGetStatus = ()=>{
+    const fetcher = ()=>fetchJson(`${GEN3_GUPPY_API}${statusEndpoint}`);
+    return useSWR('explorerStatus', fetcher);
+};
+/**
+ * The main endpoint used in templating Exploration page queries.
+ * Includes table, filter and aggregation query types and leverages guppyApi defined in ./gupplApi.ts
+ * Query templates support filters where applicable
+ *
+ * @param endpoints - Defines endpoints used in Exploration page:
+ * @param getAllFieldsForType - A mapping query that returns all property key names vertex types specified.
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#mapping-query
+ * @param getAccessibleData - An aggregation histogram counts query that filters based on access type
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#accessibility-argument-for-regular-tier-access-level
+ * @param getRawDataAndTotalCounts - Queries both _totalCount for selected vertex types and
+ * tabular results containing the raw data in the rows of selected vertex types
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#1-total-count-aggregation
+ * @param getAggs - An aggregated histogram counts query which outputs vertex property frequencies
+ * @param getSubAggs - TODO: not sure what this one does. Looks like nested aggregation
+ * @param getCounts - Returns total counts of a vertex type
+ * @returns: A guppy API endpoint for templating queriable data displayed on the exploration page
+ */ const explorerApi = guppyApi.injectEndpoints({
+    endpoints: (builder)=>({
+            getAllFieldsForType: builder.query({
+                query: (type)=>({
+                        query: `{ _mapping ${type} } }`
+                    }),
+                transformResponse: (response, _meta, params)=>{
+                    return response[params.type];
+                }
+            }),
+            getAccessibleData: builder.query({
+                query: ({ type, fields, accessType })=>{
+                    const fieldParts = fields.map((field)=>`${field} { histogram { key count } }`);
+                    return {
+                        query: `_aggregation {
+              ${type} (accessibility: ${accessType}) {
+                ${fieldParts.join(',')}
+              }
+            }`
+                    };
+                }
+            }),
+            getRawDataAndTotalCounts: builder.query({
+                query: ({ type, fields, filters, sort, offset = 0, size = 20, accessibility = exports.Accessibility.ALL, format = undefined })=>{
+                    const gqlFilter = convertFilterSetToGqlFilter(filters);
+                    const params = [
+                        ...sort ? [
+                            '$sort: JSON'
+                        ] : [],
+                        ...gqlFilter ? [
+                            '$filter: JSON'
+                        ] : [],
+                        ...format ? [
+                            '$format: Format'
+                        ] : []
+                    ].join(',');
+                    const queryLine = `query getRawDataAndTotalCounts (${params}) {`;
+                    const dataParams = [
+                        ...format ? [
+                            'format: $format'
+                        ] : [],
+                        ...sort ? [
+                            'sort: $sort'
+                        ] : [],
+                        ...gqlFilter ? [
+                            'filter: $filter'
+                        ] : []
+                    ].join(',');
+                    const dataTypeLine = `${type} (accessibility: ${accessibility}, offset: ${offset}, first: ${size},
+        ${dataParams}) {`;
+                    const typeAggsLine = `${type} (${gqlFilter && 'filter: $filter,'} accessibility: ${accessibility}) {`;
+                    const processedFields = fields.map((field)=>rawDataQueryStrForEachField(field));
+                    const query = `${queryLine}
+    ${dataTypeLine}
+      ${processedFields.join(' ')}
+            }
+            _aggregation {
+              ${typeAggsLine}
+                _totalCount
+              }
+            }
+        }`;
+                    const variables = {
+                        ...sort && {
+                            sort
+                        },
+                        ...gqlFilter && {
+                            filter: gqlFilter
+                        },
+                        ...format && {
+                            format
+                        }
+                    };
+                    return {
+                        query,
+                        variables
+                    };
+                }
+            }),
+            getAggs: builder.query({
+                query: ({ type, fields, filters, accessibility = exports.Accessibility.ALL })=>{
+                    const queryStart = isFilterEmpty(filters) ? `
+              query getAggs {
+              _aggregation {
+              ${type} (accessibility: ${accessibility}) {` : `query getAggs ($filter: JSON) {
+               _aggregation {
+                      ${type} (filter: $filter, filterSelf: false, accessibility: ${accessibility}) {`;
+                    const query = `${queryStart}
+                  ${fields.map((field)=>histogramQueryStrForEachField(field))}
+                }
+              }
+            }`;
+                    const queryBody = {
+                        query: query,
+                        variables: {
+                            filter: convertFilterSetToGqlFilter(filters)
+                        }
+                    };
+                    return queryBody;
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return processHistogramResponse(response.data._aggregation[args.type]);
+                }
+            }),
+            getSubAggs: builder.query({
+                query: ({ type, mainField, termsFields = undefined, missingFields = undefined, numericAggAsText = false, gqlFilter = undefined, accessibility = exports.Accessibility.ALL })=>{
+                    const nestedAggFields = {
+                        termsFields: termsFields,
+                        missingFields: missingFields
+                    };
+                    const query = `query getSubAggs ( ${gqlFilter ?? '$filter: JSON,'} $nestedAggFields: JSON) {
+    _aggregation {
+      ${type} ( ${gqlFilter ?? 'filter: $filter, filterSelf: false,'} nestedAggFields: $nestedAggFields, accessibility: ${accessibility}) {
+        ${nestedHistogramQueryStrForEachField(mainField, numericAggAsText)}
+      }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilter && {
+                                filter: convertFilterSetToGqlFilter(gqlFilter)
+                            },
+                            nestedAggFields: nestedAggFields
+                        }
+                    };
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return processHistogramResponse(response.data._aggregation[args.type]);
+                }
+            }),
+            getCounts: builder.query({
+                query: ({ type, filters, accessibility = exports.Accessibility.ALL })=>{
+                    const gqlFilters = convertFilterSetToGqlFilter(filters);
+                    const queryLine = `query totalCounts ${gqlFilters ? '($filter: JSON)' : ''}{`;
+                    const typeAggsLine = `${type} ${gqlFilters ? '(filter: $filter, ' : '('} accessibility: ${accessibility}) {`;
+                    const query = `${queryLine} _aggregation {
+          ${typeAggsLine}
+            _totalCount
+            }
+           }
+        }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilters && {
+                                filter: gqlFilters
+                            }
+                        }
+                    };
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return response.data._aggregation[args.type]._totalCount;
+                }
+            }),
+            getFieldCountSummary: builder.query({
+                query: ({ type, field, filters })=>{
+                    const gqlFilters = convertFilterSetToGqlFilter(filters);
+                    const query = `query ($filter: JSON) {
+        _aggregation {
+          ${type} (filter: $filter) {
+            ${field} {
+              histogram {
+                sum
+              }
+            }
+          }
+        }
+      }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilters && {
+                                filter: gqlFilters
+                            }
+                        }
+                    };
+                }
+            }),
+            getFieldsForIndex: builder.query({
+                query: (index)=>{
+                    return {
+                        query: `{
+            _mapping ${index}
+          }`
+                    };
+                },
+                transformResponse: (response)=>{
+                    return response['_mapping'];
+                }
+            }),
+            generalGQL: builder.query({
+                query: ({ query, variables })=>{
+                    return {
+                        query: query,
+                        variables: variables
+                    };
+                }
+            })
+        })
+});
+// query for aggregate data
+// convert the function below to typescript
+const histogramQueryStrForEachField = (field)=>{
+    const splittedFieldArray = field.split('.');
+    const splittedField = splittedFieldArray.shift();
+    if (splittedFieldArray.length === 0) {
+        return `
+    ${splittedField} {
+      histogram {
+        key
+        count
+      }
+    }`;
+    }
+    return `
+  ${splittedField} {
+    ${histogramQueryStrForEachField(splittedFieldArray.join('.'))}
+  }`;
+};
+const nestedHistogramQueryStrForEachField = (mainField, numericAggAsText)=>`
+  ${mainField} {
+    ${numericAggAsText ? 'asTextHistogram' : 'histogram'} {
+      key
+      count
+      missingFields {
+        field
+        count
+      }
+      termsFields {
+        field
+        count
+        terms {
+          key
+          count
+        }
+      }
+    }
+  }`;
+const rawDataQueryStrForEachField = (field)=>{
+    const splitFieldArray = field.split('.');
+    const splitField = splitFieldArray.shift();
+    if (splitFieldArray.length === 0) {
+        return `
+    ${splitField}
+    `;
+    }
+    return `
+  ${splitField} {
+    ${rawDataQueryStrForEachField(splitFieldArray.join('.'))}
+  }`;
+};
+const useGetArrayTypes = ()=>{
+    {
+        const { data, error } = useGetStatus();
+        if (error) {
+            return {};
+        }
+        return data ? data['indices'] : {};
+    }
+};
+const { useGetRawDataAndTotalCountsQuery, useGetAccessibleDataQuery, useGetAllFieldsForTypeQuery, useGetAggsQuery, useGetSubAggsQuery, useGetCountsQuery, useGetFieldCountSummaryQuery, useGetFieldsForIndexQuery, useGeneralGQLQuery, useLazyGeneralGQLQuery } = explorerApi;
+const EmptyAggData = {};
+const selectAggDataForIndex = (state, index, field)=>{
+    const data = state.guppyApi.aggs[index]?.[field]?.histogram;
+    return data ?? EmptyAggData;
+};
+
+/**
+ * Flattens a deep nested JSON object skipping
+ * the first level to avoid potentially flattening
+ * non-nested data.
+ * @param {JSON} json
+ */ function flattenJson(json) {
+    const flattenedJson = [];
+    Object.keys(json).forEach((key)=>{
+        flattenedJson.push(flat.flatten(json[key], {
+            delimiter: '_'
+        }));
+    });
+    return flattenedJson;
+}
+/**
+ * Converts JSON based on a config.
+ * @param {JSON} json
+ * @param {Object} config
+ */ async function conversion(json, config) {
+    return Papa.unparse(json, config);
+}
+/**
+ * Converts JSON to a specified file format.
+ * Defaults to JSON if file format is not supported.
+ * @param {JSON} json
+ * @param {string} format
+ */ async function jsonToFormat(json, format) {
+    if (Object.keys(FILE_DELIMITERS).includes(format)) {
+        const flatJson = await flattenJson(json);
+        const data = await conversion(flatJson, {
+            delimiter: FILE_DELIMITERS[format]
+        });
+        return data;
+    }
+    return json;
+}
+
+/**
+ * Prepares a URL for downloading by appending '/download' to the provided apiUrl.
+ *
+ * @param {string} apiUrl - The base URL to be used for preparing the download URL.
+ * @returns {URL} - The prepared download URL as a URL object.
+ */ const prepareUrl = (apiUrl)=>new URL(apiUrl + '/download');
+/**
+ * Prepares a fetch configuration object for downloading files from Guppy.
+ *
+ * @param {GuppyFileDownloadRequestParams} parameters - The parameters to include in the request body.
+ * @param {string} csrfToken - The CSRF token to include in the request headers.
+ * @returns {FetchConfig} - The prepared fetch configuration object.
+ */ const prepareFetchConfig = (parameters, csrfToken)=>{
+    return {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...csrfToken !== undefined && {
+                'X-CSRF-Token': csrfToken
+            }
+        },
+        body: JSON.stringify({
+            type: parameters.type,
+            filter: convertFilterSetToGqlFilter(parameters.filter),
+            accessibility: parameters.accessibility,
+            fields: parameters?.fields,
+            sort: parameters?.sort
+        })
+    };
+};
+/**
+ * Downloads a file from Guppy using the provided parameters.
+ * It will optionally convert the data to the specified format.
+ *
+ * @param {DownloadFromGuppyParams} parameters - The parameters to use for the download request.
+ * @param onStart - The function to call when the download starts.
+ * @param onDone - The function to call when the download is done.
+ * @param onError - The function to call when the download fails.
+ * @param onAbort - The function to call when the download is aborted.
+ * @param signal - AbortSignal to use for the request.
+ */ const downloadFromGuppyToBlob = async ({ parameters, onStart = ()=>null, onDone = (_)=>null, onError = (_)=>null, onAbort = ()=>null, signal = undefined })=>{
+    const csrfToken = selectCSRFToken(coreStore.getState());
+    onStart?.();
+    const url = prepareUrl(GEN3_GUPPY_API);
+    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
+    fetch(url.toString(), {
+        ...fetchConfig,
+        ...signal ? {
+            signal: signal
+        } : {}
+    }).then(async (response)=>{
+        if (!response.ok) {
+            throw new Error(response.statusText);
+        }
+        let jsonData = await response.json();
+        if (parameters?.rootPath && parameters.rootPath) {
+            // if rootPath is provided, extract the data from the rootPath
+            jsonData = jsonpathPlus.JSONPath({
+                json: jsonData,
+                path: `$.[${parameters.rootPath}]`,
+                resultType: 'value'
+            });
+        }
+        // convert the data to the specified format and return a Blob
+        let str = '';
+        if (parameters.format === 'json') {
+            str = JSON.stringify(jsonData);
+        } else {
+            const convertedData = await jsonToFormat(jsonData, parameters.format);
+            if (isJSONObject(convertedData)) {
+                str = JSON.stringify(convertedData, null, 2);
+            } else {
+                str = convertedData;
+            }
+        }
+        return new Blob([
+            str
+        ], {
+            type: 'application/json'
+        });
+    }).then((blob)=>onDone?.(blob)).catch((error)=>{
+        // Abort is handle as an exception
+        if (error.name == 'AbortError') {
+            // handle abort()
+            onAbort?.();
+        }
+        onError?.(error);
+    });
+};
+const downloadJSONDataFromGuppy = async ({ parameters, onAbort = ()=>null, signal = undefined })=>{
+    const csrfToken = selectCSRFToken(coreStore.getState());
+    const url = prepareUrl(GEN3_GUPPY_API);
+    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
+    try {
+        const response = await fetch(url.toString(), {
+            ...fetchConfig,
+            ...signal ? {
+                signal: signal
+            } : {}
+        });
+        let jsonData = await response.json();
+        if (parameters?.rootPath && parameters.rootPath) {
+            // if rootPath is provided, extract the data from the rootPath
+            jsonData = jsonpathPlus.JSONPath({
+                json: jsonData,
+                path: `$.[${parameters.rootPath}]`,
+                resultType: 'value'
+            });
+        }
+        // convert the data to the specified format and return a Blob
+        return jsonData;
+    } catch (error) {
+        // Abort is handle as an exception
+        if (error.name == 'AbortError') {
+            // handle abort()
+            onAbort?.();
+        }
+        throw new Error(error);
+    }
+};
+const useGetIndexFields = (index)=>{
+    const { data } = useGetFieldsForIndexQuery(index);
+    return data ?? [];
+};
+
+/**
+ * Creates a Guppy API for fetching bulk (> 10K rows) elasticsearch data
+ * @see https://github.com/uc-cdis/guppy/blob/master/doc/download.md
+ * @param endpoints - Resolver function which configures the query with
+ * type, filter, accessibility, fields, and sort arguments
+ * @returns: A guppy download API for fetching bulk metadata
+ */ const downloadRequestApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            downloadFromGuppy: builder.mutation({
+                query: ({ type, filter, accessibility, fields, sort })=>{
+                    const queryBody = {
+                        filter: convertFilterSetToGqlFilter(filter),
+                        ...{
+                            type,
+                            accessibility,
+                            fields,
+                            sort
+                        }
+                    };
+                    return {
+                        url: `${GEN3_GUPPY_API}/download`,
+                        method: 'POST',
+                        queryBody,
+                        cache: 'no-cache'
+                    };
+                },
+                transformResponse: (response)=>{
+                    return response;
+                }
+            })
+        })
+});
+const { useDownloadFromGuppyMutation } = downloadRequestApi;
+
+/**
+ * returns a response from the AI search service
+ * @param searchParams - the parameters for the AI search service
+ * @returns the response from the AI search service
+ */ const aiSearchApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            askQuestion: builder.mutation({
+                query: (searchParams)=>({
+                        url: `${GEN3_AI_SEARCH_API}/ask`,
+                        method: 'POST',
+                        credentials: 'include',
+                        headers: {
+                            Accept: 'application/json',
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            query: searchParams.query,
+                            ...searchParams.topic ? {
+                                topic: searchParams.topic
+                            } : {},
+                            ...searchParams.conversationId ? {
+                                conversation_id: searchParams.conversationId
+                            } : {}
+                        })
+                    }),
+                transformResponse: (data, _, arg)=>{
+                    return {
+                        query: arg.query,
+                        response: data.response,
+                        topic: data.topic,
+                        conversationId: data.conversation_id,
+                        documents: data.documents
+                    };
+                }
+            }),
+            /**
+     * returns the status of the AI search service
+     * @returns {
+     *   status: string
+     *   timestamp: string
+     * }
+     */ getAISearchStatus: builder.query({
+                query: ()=>`${GEN3_AI_SEARCH_API}/_status`
+            }),
+            getAISearchVersion: builder.query({
+                query: ()=>`${GEN3_AI_SEARCH_API}/_version`
+            })
+        })
+});
+// Add more endpoints here
+const { useAskQuestionMutation, useGetAISearchStatusQuery, useGetAISearchVersionQuery } = aiSearchApi;
+
+const workspacesApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getWorkspaceOptions: builder.query({
+                query: ()=>`${GEN3_WORKSPACE_STATUS_API}/options`
+            }),
+            getWorkspacePayModels: builder.query({
+                query: ()=>`${GEN3_WORKSPACE_STATUS_API}/allpaymodels`
+            }),
+            getWorkspaceStatus: builder.query({
+                query: ()=>`${GEN3_WORKSPACE_STATUS_API}/status`
+            })
+        })
+});
+const { useGetWorkspaceOptionsQuery, useGetWorkspacePayModelsQuery, useGetWorkspaceStatusQuery } = workspacesApi;
+
+const resourcePathFromProjectID = (projectID)=>{
+    const split = projectID.split('-');
+    const program = split[0];
+    const project = split.slice(1).join('-');
+    const resourcePath = [
+        '/programs',
+        program,
+        'projects',
+        project
+    ].join('/');
+    return resourcePath;
+};
+const isRootUrl = (urlFragment)=>urlFragment === '_root';
+const isProgramUrl = (urlFragment)=>urlFragment !== '_root' && !urlFragment.includes('-');
+const userHasSheepdogProgramAdmin = (userAuthMapping = {})=>userAuthMapping['/services/sheepdog/submission/program'] !== undefined;
+const userHasSheepdogProjectAdmin = (userAuthMapping = {})=>userAuthMapping['/services/sheepdog/submission/project'] !== undefined;
+const projectCodeFromResourcePath = (resourcePath)=>{
+    const split = resourcePath.split('/');
+    return split.length < 5 || split[1] !== 'programs' || split[3] !== 'projects' ? '' : split[4];
+};
+const listifyMethodsFromMapping = (actions)=>{
+    const reducer = (accumulator, currval)=>accumulator.concat([
+            currval.method
+        ]);
+    return actions.reduce(reducer, []);
+};
+const userHasDataUpload = (userAuthMapping = {})=>{
+    const actionIsFileUpload = (x)=>x.method === 'file_upload';
+    const resource = userAuthMapping['/data_file'];
+    return resource !== undefined && resource.some(actionIsFileUpload);
+};
+const userHasMethodForServiceOnResource = (method, service, resourcePath, userAuthMapping = {})=>{
+    const actions = userAuthMapping[resourcePath];
+    return actions !== undefined && actions.some((x)=>(x.service === service || x.service === '*') && (x.method === method || x.method === '*'));
+};
+const userHasMethodForServiceOnProject = (method, service, projectID, userAuthMapping = {})=>{
+    const resourcePath = resourcePathFromProjectID(projectID);
+    return userHasMethodForServiceOnResource(method, service, resourcePath, userAuthMapping);
+};
+const userHasMethodOnAnyProject = (method, userAuthMapping = {})=>{
+    const actionHasMethod = (x)=>x.method === method;
+    const actionArrays = Object.values(userAuthMapping);
+    const hasMethod = actionArrays.some((x)=>x.some(actionHasMethod));
+    return hasMethod;
+};
+const userHasCreateOrUpdateOnAnyProject = (userAuthMapping = {})=>userHasMethodOnAnyProject('create', userAuthMapping) || userHasMethodOnAnyProject('update', userAuthMapping);
+
+const extractValuesFromObject = (jsonPathMappings, obj)=>{
+    const result = {};
+    const extractObjectValue = (jsonPath, obj)=>{
+        const extractedValues = jsonpathPlus.JSONPath({
+            path: jsonPath,
+            json: obj
+        });
+        return extractedValues.length > 0 ? extractedValues[0] : undefined;
+    };
+    for(const key in jsonPathMappings){
+        if (key in Object.keys(jsonPathMappings)) {
+            // Extract value from object and store it in the result.
+            result[key] = extractObjectValue(jsonPathMappings[key], obj);
+        }
+    }
+    return result;
+};
+
+const SubmissionGraphqlQuery = `query transactionList {
+    transactionList: transaction_log(last: 20) {
+      id
+      submitter
+      project_id
+      created_datetime
+      documents {
+        doc_size
+        doc
+        id
+      }
+      state
+    }
+}`;
+/**
+ * Defines submissionApi service using a base URL and expected endpoints. Derived from gen3Api core API.
+ * @param endpoints - Defines endpoints used in submission page
+ * @param getProjects - Queries the list of projects
+ * @param getProjectsDetails - Queries the list of projects and their details
+ * @param getSubmissionGraphQL - Queries the submission graphql with a query and variables
+ * @returns: A submission API for fetching project details
+ */ const submissionApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getProjects: builder.query({
+                query: (graphQLParams)=>({
+                        url: `${GEN3_SUBMISSION_API}/graphql`,
+                        method: 'POST',
+                        credentials: 'include',
+                        body: JSON.stringify(graphQLParams)
+                    }),
+                transformResponse: (response, _meta)=>{
+                    return {
+                        projects: response.data.project
+                    };
+                }
+            }),
+            getSubmissions: builder.query({
+                query: ()=>({
+                        url: `${GEN3_SUBMISSION_API}/graphql`,
+                        method: 'POST',
+                        credentials: 'include',
+                        body: JSON.stringify({
+                            query: SubmissionGraphqlQuery
+                        })
+                    }),
+                transformResponse: (response, _meta)=>{
+                    return {
+                        transactionList: response.data.transactionList
+                    };
+                }
+            }),
+            getProjectsDetails: builder.query({
+                async queryFn (args, _queryApi, _extraOptions, fetchWithBQ) {
+                    // get the list of projects
+                    const projectsResponse = await fetchWithBQ({
+                        url: `${GEN3_SUBMISSION_API}/graphql`,
+                        method: 'POST',
+                        credentials: 'include',
+                        body: JSON.stringify(args.projectQuery)
+                    });
+                    if (projectsResponse.error) return {
+                        error: projectsResponse.error
+                    };
+                    const projects = projectsResponse?.data.data.project;
+                    const projectIds = projects.map((p)=>p.project_id);
+                    // given the list of projects, get all of them by executing the projectDetailsQuery for each project
+                    const projectDetails = await Promise.all(projectIds.map(async (projectId)=>{
+                        const result = await fetchWithBQ({
+                            url: `${GEN3_SUBMISSION_API}/graphql`,
+                            method: 'POST',
+                            credentials: 'include',
+                            body: JSON.stringify({
+                                ...args.projectDetailsQuery,
+                                variables: {
+                                    name: projectId
+                                }
+                            })
+                        });
+                        const { project, ...values } = result.data.data;
+                        return result.data ? {
+                            data: args.mapping ? {
+                                ...extractValuesFromObject(args.mapping, values),
+                                project: project[0]
+                            } : {
+                                ...values,
+                                project: project[0]
+                            }
+                        } : {
+                            error: result.error
+                        };
+                    }));
+                    // if any of the projectDetails has an error, return the error
+                    if (projectDetails.some((detail)=>'error' in detail)) {
+                        return {
+                            error: projectDetails.find((detail)=>'error' in detail)
+                        };
+                    } else return {
+                        data: {
+                            details: projectDetails.reduce((acc, detail)=>{
+                                acc.push(detail.data ?? {
+                                    project: {
+                                        name: '',
+                                        id: '',
+                                        code: ''
+                                    }
+                                });
+                                return acc;
+                            }, []),
+                            hits: projectIds.length
+                        }
+                    };
+                }
+            }),
+            getSubmissionGraphQL: builder.query({
+                query: (graphQLParams)=>({
+                        url: `${GEN3_SUBMISSION_API}/graphql`,
+                        method: 'POST',
+                        credentials: 'include',
+                        body: JSON.stringify({
+                            query: graphQLParams.query,
+                            ...graphQLParams.variables ? {
+                                variables: graphQLParams.variables
+                            } : {}
+                        })
+                    }),
+                transformResponse: (response, _meta, params)=>{
+                    if (params.mapping) {
+                        return {
+                            data: extractValuesFromObject(params.mapping, response.data)
+                        };
+                    }
+                    return response.data;
+                }
+            }),
+            getDictionary: builder.query({
+                query: ()=>({
+                        url: `${GEN3_SUBMISSION_API}/_dictionary/_all/`
+                    })
+            })
+        })
+});
+const { useGetProjectsQuery, useGetSubmissionGraphQLQuery, useGetProjectsDetailsQuery, useLazyGetProjectsQuery, useLazyGetSubmissionGraphQLQuery, useGetSubmissionsQuery, useGetDictionaryQuery } = submissionApi;
+
+exports.CoreContext = CoreContext;
+exports.CoreProvider = CoreProvider;
+exports.GEN3_API = GEN3_API;
+exports.GEN3_AUTHZ_API = GEN3_AUTHZ_API;
+exports.GEN3_COMMONS_NAME = GEN3_COMMONS_NAME;
+exports.GEN3_CROSSWALK_API = GEN3_CROSSWALK_API;
+exports.GEN3_DOMAIN = GEN3_DOMAIN;
+exports.GEN3_DOWNLOADS_ENDPOINT = GEN3_DOWNLOADS_ENDPOINT;
+exports.GEN3_FENCE_API = GEN3_FENCE_API;
+exports.GEN3_GUPPY_API = GEN3_GUPPY_API;
+exports.GEN3_MDS_API = GEN3_MDS_API;
+exports.GEN3_REDIRECT_URL = GEN3_REDIRECT_URL;
+exports.GEN3_SUBMISSION_API = GEN3_SUBMISSION_API;
+exports.GEN3_WORKSPACE_STATUS_API = GEN3_WORKSPACE_STATUS_API;
+exports.clearCohortFilters = clearCohortFilters;
+exports.cohortReducer = cohortReducer;
+exports.convertFilterSetToGqlFilter = convertFilterSetToGqlFilter;
+exports.coreStore = coreStore;
+exports.createGen3App = createGen3App;
+exports.createUseCoreDataHook = createUseCoreDataHook;
+exports.downloadFromGuppyToBlob = downloadFromGuppyToBlob;
+exports.downloadJSONDataFromGuppy = downloadJSONDataFromGuppy;
+exports.drsHostnamesReducer = drsHostnamesReducer;
+exports.extractEnumFilterValue = extractEnumFilterValue;
+exports.extractFieldNameFromFullFieldName = extractFieldNameFromFullFieldName;
+exports.extractFilterValue = extractFilterValue;
+exports.extractIndexAndFieldNameFromFullFieldName = extractIndexAndFieldNameFromFullFieldName;
+exports.extractIndexFromFullFieldName = extractIndexFromFullFieldName;
+exports.fetchFence = fetchFence;
+exports.fetchJson = fetchJson;
+exports.fetchUserState = fetchUserState;
+exports.fieldNameToTitle = fieldNameToTitle;
+exports.gen3Api = gen3Api;
+exports.getGen3AppId = getGen3AppId;
+exports.graphQLAPI = graphQLAPI;
+exports.graphQLWithTags = graphQLWithTags;
+exports.guppyAPISliceMiddleware = guppyAPISliceMiddleware;
+exports.guppyApi = guppyApi;
+exports.guppyApiReducer = guppyApiReducer;
+exports.guppyApiSliceReducerPath = guppyApiSliceReducerPath;
+exports.handleOperation = handleOperation;
+exports.hideModal = hideModal;
+exports.isAuthenticated = isAuthenticated;
+exports.isErrorWithMessage = isErrorWithMessage;
+exports.isFetchBaseQueryError = isFetchBaseQueryError;
+exports.isFetchParseError = isFetchParseError;
+exports.isFilterEmpty = isFilterEmpty;
+exports.isGuppyAggregationData = isGuppyAggregationData;
+exports.isHistogramData = isHistogramData;
+exports.isHistogramDataAArray = isHistogramDataAArray;
+exports.isHistogramDataAnEnum = isHistogramDataAnEnum;
+exports.isHistogramDataArray = isHistogramDataArray;
+exports.isHistogramDataArrayARange = isHistogramDataArrayARange;
+exports.isHistogramDataArrayAnEnum = isHistogramDataArrayAnEnum;
+exports.isHistogramDataCollection = isHistogramDataCollection;
+exports.isHistogramRangeData = isHistogramRangeData;
+exports.isJSONObject = isJSONObject;
+exports.isJSONValue = isJSONValue;
+exports.isJSONValueArray = isJSONValueArray;
+exports.isOperationWithField = isOperationWithField;
+exports.isPending = isPending;
+exports.isProgramUrl = isProgramUrl;
+exports.isRootUrl = isRootUrl;
+exports.listifyMethodsFromMapping = listifyMethodsFromMapping;
+exports.logoutFence = logoutFence;
+exports.prependIndexToFieldName = prependIndexToFieldName;
+exports.projectCodeFromResourcePath = projectCodeFromResourcePath;
+exports.rawDataQueryStrForEachField = rawDataQueryStrForEachField;
+exports.removeCohortFilter = removeCohortFilter;
+exports.resetUserState = resetUserState;
+exports.resourcePathFromProjectID = resourcePathFromProjectID;
+exports.selectAggDataForIndex = selectAggDataForIndex;
+exports.selectAuthzMappingData = selectAuthzMappingData;
+exports.selectCSRFToken = selectCSRFToken;
+exports.selectCSRFTokenData = selectCSRFTokenData;
+exports.selectCohortFilters = selectCohortFilters;
+exports.selectCurrentCohort = selectCurrentCohort;
+exports.selectCurrentCohortId = selectCurrentCohortId;
+exports.selectCurrentCohortName = selectCurrentCohortName;
+exports.selectCurrentMessage = selectCurrentMessage;
+exports.selectCurrentModal = selectCurrentModal;
+exports.selectGen3AppById = selectGen3AppById;
+exports.selectGen3AppMetadataById = selectGen3AppMetadataById;
+exports.selectHeadersWithCSRFToken = selectHeadersWithCSRFToken;
+exports.selectIndexFilters = selectIndexFilters;
+exports.selectIndexedFilterByName = selectIndexedFilterByName;
+exports.selectUser = selectUser;
+exports.selectUserAuthStatus = selectUserAuthStatus;
+exports.selectUserData = selectUserData;
+exports.selectUserDetails = selectUserDetails;
+exports.selectUserLoginStatus = selectUserLoginStatus;
+exports.setDRSHostnames = setDRSHostnames;
+exports.showModal = showModal;
+exports.submissionApi = submissionApi;
+exports.trimFirstFieldNameToTitle = trimFirstFieldNameToTitle;
+exports.updateCohortFilter = updateCohortFilter;
+exports.useAddNewCredentialMutation = useAddNewCredentialMutation;
+exports.useAskQuestionMutation = useAskQuestionMutation;
+exports.useAuthorizeFromCredentialsMutation = useAuthorizeFromCredentialsMutation;
+exports.useCoreDispatch = useCoreDispatch;
+exports.useCoreSelector = useCoreSelector;
+exports.useCoreStore = useCoreStore;
+exports.useDownloadFromGuppyMutation = useDownloadFromGuppyMutation;
+exports.useFetchUserDetailsQuery = useFetchUserDetailsQuery;
+exports.useGeneralGQLQuery = useGeneralGQLQuery;
+exports.useGetAISearchStatusQuery = useGetAISearchStatusQuery;
+exports.useGetAISearchVersionQuery = useGetAISearchVersionQuery;
+exports.useGetAccessibleDataQuery = useGetAccessibleDataQuery;
+exports.useGetAggMDSQuery = useGetAggMDSQuery;
+exports.useGetAggsQuery = useGetAggsQuery;
+exports.useGetAllFieldsForTypeQuery = useGetAllFieldsForTypeQuery;
+exports.useGetArrayTypes = useGetArrayTypes;
+exports.useGetAuthzMappingsQuery = useGetAuthzMappingsQuery;
+exports.useGetCSRFQuery = useGetCSRFQuery;
+exports.useGetCountsQuery = useGetCountsQuery;
+exports.useGetCredentialsQuery = useGetCredentialsQuery;
+exports.useGetCrosswalkDataQuery = useGetCrosswalkDataQuery;
+exports.useGetDataQuery = useGetDataQuery;
+exports.useGetDictionaryQuery = useGetDictionaryQuery;
+exports.useGetExternalLoginsQuery = useGetExternalLoginsQuery;
+exports.useGetFieldCountSummaryQuery = useGetFieldCountSummaryQuery;
+exports.useGetFieldsForIndexQuery = useGetFieldsForIndexQuery;
+exports.useGetIndexAggMDSQuery = useGetIndexAggMDSQuery;
+exports.useGetIndexFields = useGetIndexFields;
+exports.useGetJWKKeysQuery = useGetJWKKeysQuery;
+exports.useGetLoginProvidersQuery = useGetLoginProvidersQuery;
+exports.useGetMDSQuery = useGetMDSQuery;
+exports.useGetProjectsDetailsQuery = useGetProjectsDetailsQuery;
+exports.useGetProjectsQuery = useGetProjectsQuery;
+exports.useGetRawDataAndTotalCountsQuery = useGetRawDataAndTotalCountsQuery;
+exports.useGetStatus = useGetStatus;
+exports.useGetSubAggsQuery = useGetSubAggsQuery;
+exports.useGetSubmissionGraphQLQuery = useGetSubmissionGraphQLQuery;
+exports.useGetSubmissionsQuery = useGetSubmissionsQuery;
+exports.useGetTagsQuery = useGetTagsQuery;
+exports.useGetWorkspaceOptionsQuery = useGetWorkspaceOptionsQuery;
+exports.useGetWorkspacePayModelsQuery = useGetWorkspacePayModelsQuery;
+exports.useGetWorkspaceStatusQuery = useGetWorkspaceStatusQuery;
+exports.useGraphQLQuery = useGraphQLQuery;
+exports.useIsExternalConnectedQuery = useIsExternalConnectedQuery;
+exports.useIsUserLoggedIn = useIsUserLoggedIn;
+exports.useLazyFetchUserDetailsQuery = useLazyFetchUserDetailsQuery;
+exports.useLazyGeneralGQLQuery = useLazyGeneralGQLQuery;
+exports.useLazyGetCrosswalkDataQuery = useLazyGetCrosswalkDataQuery;
+exports.useLazyGetExternalLoginsQuery = useLazyGetExternalLoginsQuery;
+exports.useLazyGetProjectsQuery = useLazyGetProjectsQuery;
+exports.useLazyGetSubmissionGraphQLQuery = useLazyGetSubmissionGraphQLQuery;
+exports.useLazyIsExternalConnectedQuery = useLazyIsExternalConnectedQuery;
+exports.usePrevious = usePrevious;
+exports.useRemoveCredentialMutation = useRemoveCredentialMutation;
+exports.useUser = useUser;
+exports.useUserAuth = useUserAuth;
+exports.userHasCreateOrUpdateOnAnyProject = userHasCreateOrUpdateOnAnyProject;
+exports.userHasDataUpload = userHasDataUpload;
+exports.userHasMethodForServiceOnProject = userHasMethodForServiceOnProject;
+exports.userHasMethodForServiceOnResource = userHasMethodForServiceOnResource;
+exports.userHasMethodOnAnyProject = userHasMethodOnAnyProject;
+exports.userHasSheepdogProgramAdmin = userHasSheepdogProgramAdmin;
+exports.userHasSheepdogProjectAdmin = userHasSheepdogProjectAdmin;
+//# sourceMappingURL=index.js.map