@orchestrator-ui/orchestrator-ui-components 3.10.0 → 4.0.1

package/dist/index.js

@@ -26798,7 +26798,7 @@ var PolicyResource = /* @__PURE__ */ ((PolicyResource2) => {
 })(PolicyResource || {});
 
 // src/configuration/version.ts
-var ORCHESTRATOR_UI_LIBRARY_VERSION = "3.10.0";
+var ORCHESTRATOR_UI_LIBRARY_VERSION = "4.0.1";
 
 // src/types/types.ts
 var EngineStatus = /* @__PURE__ */ ((EngineStatus3) => {
@@ -28609,19 +28609,9 @@ function freezeDraftable(val) {
   return isDraftable(val) ? produce(val, () => {
   }) : val;
 }
-function emplace(map, key, handler) {
-  if (map.has(key)) {
-    let value = map.get(key);
-    if (handler.update) {
-      value = handler.update(value, key, map);
-      map.set(key, value);
-    }
-    return value;
-  }
-  if (!handler.insert) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(10) : "No insert provided for key not already in map");
-  const inserted = handler.insert(key, map);
-  map.set(key, inserted);
-  return inserted;
+function getOrInsertComputed(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
 }
 function isImmutableDefault(value) {
   return typeof value !== "object" || value == null || Object.isFrozen(value);
@@ -28759,7 +28749,7 @@ function isPlain(val) {
   const type = typeof val;
   return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || isPlainObject(val);
 }
-function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache3) {
+function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache2) {
   let foundNestedSerializable;
   if (!isSerializable(value)) {
     return {
@@ -28770,7 +28760,7 @@ function findNonSerializableValue(value, path = "", isSerializable = isPlain, ge
   if (typeof value !== "object" || value === null) {
     return false;
   }
-  if (cache3?.has(value)) return false;
+  if (cache2?.has(value)) return false;
   const entries = getEntries != null ? getEntries(value) : Object.entries(value);
   const hasIgnoredPaths = ignoredPaths.length > 0;
   for (const [key, nestedValue] of entries) {
@@ -28793,13 +28783,13 @@ function findNonSerializableValue(value, path = "", isSerializable = isPlain, ge
       };
     }
     if (typeof nestedValue === "object") {
-      foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache3);
+      foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache2);
       if (foundNestedSerializable) {
         return foundNestedSerializable;
       }
     }
   }
-  if (cache3 && isNestedFrozen(value)) cache3.add(value);
+  if (cache2 && isNestedFrozen(value)) cache2.add(value);
   return false;
 }
 function isNestedFrozen(value) {
@@ -28825,7 +28815,7 @@ function createSerializableStateInvariantMiddleware(options = {}) {
       ignoreActions = false,
       disableCache = false
     } = options;
-    const cache3 = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
+    const cache2 = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
     return (storeAPI) => (next) => (action) => {
       if (!isAction(action)) {
         return next(action);
@@ -28834,7 +28824,7 @@ function createSerializableStateInvariantMiddleware(options = {}) {
       const measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
       if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
         measureUtils.measureTime(() => {
-          const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache3);
+          const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache2);
           if (foundActionNonSerializableValue) {
             const {
               keyPath,
@@ -28847,7 +28837,7 @@ function createSerializableStateInvariantMiddleware(options = {}) {
       if (!ignoreState) {
         measureUtils.measureTime(() => {
           const state = storeAPI.getState();
-          const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache3);
+          const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache2);
           if (foundStateNonSerializableValue) {
             const {
               keyPath,
@@ -28919,7 +28909,6 @@ var createQueueWithTimer = (timeout) => {
     setTimeout(notify, timeout);
   };
 };
-var rAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);
 var autoBatchEnhancer = (options = {
   type: "raf"
 }) => (next) => (...args) => {
@@ -28928,7 +28917,10 @@ var autoBatchEnhancer = (options = {
   let shouldNotifyAtEndOfTick = false;
   let notificationQueued = false;
   const listeners = /* @__PURE__ */ new Set();
-  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? rAF : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
+  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? (
+    // requestAnimationFrame won't exist in SSR environments. Fall back to a vague approximation just to keep from erroring.
+    typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10)
+  ) : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
   const notifyListeners = () => {
     notificationQueued = false;
     if (shouldNotifyAtEndOfTick) {
@@ -28983,6 +28975,7 @@ function configureStore(options) {
     reducer = void 0,
     middleware,
     devTools = true,
+    duplicateMiddlewareCheck = true,
     preloadedState = void 0,
     enhancers = void 0
   } = options || {};
@@ -29009,6 +29002,15 @@ function configureStore(options) {
   if (process.env.NODE_ENV !== "production" && finalMiddleware.some((item) => typeof item !== "function")) {
     throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(4) : "each middleware provided to configureStore must be a function");
   }
+  if (process.env.NODE_ENV !== "production" && duplicateMiddlewareCheck) {
+    let middlewareReferences = /* @__PURE__ */ new Set();
+    finalMiddleware.forEach((middleware2) => {
+      if (middlewareReferences.has(middleware2)) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(42) : "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.");
+      }
+      middlewareReferences.add(middleware2);
+    });
+  }
   let finalCompose = compose;
   if (devTools) {
     finalCompose = composeWithDevTools({
@@ -29260,6 +29262,7 @@ var miniSerializeError = (value) => {
     message: String(value)
   };
 };
+var externalAbortMessage = "External signal was aborted";
 var createAsyncThunk = /* @__PURE__ */ (() => {
   function createAsyncThunk2(typePrefix, payloadCreator, options) {
     const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
@@ -29293,7 +29296,9 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
         condition: error?.name === "ConditionError"
       }
     }));
-    function actionCreator(arg) {
+    function actionCreator(arg, {
+      signal
+    } = {}) {
       return (dispatch, getState, extra) => {
         const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
         const abortController = new AbortController();
@@ -29303,6 +29308,15 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
           abortReason = reason;
           abortController.abort();
         }
+        if (signal) {
+          if (signal.aborted) {
+            abort(externalAbortMessage);
+          } else {
+            signal.addEventListener("abort", () => abort(externalAbortMessage), {
+              once: true
+            });
+          }
+        }
         const promise = async function() {
           let finalAction;
           try {
@@ -29504,6 +29518,7 @@ function buildCreateSlice({
     }
     const selectSelf = (state) => state;
     const injectedSelectorCache = /* @__PURE__ */ new Map();
+    const injectedStateCache = /* @__PURE__ */ new WeakMap();
     let _reducer;
     function reducer(state, action) {
       if (!_reducer) _reducer = buildReducer();
@@ -29518,7 +29533,7 @@ function buildCreateSlice({
         let sliceState = state[reducerPath2];
         if (typeof sliceState === "undefined") {
           if (injected) {
-            sliceState = getInitialState();
+            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
           } else if (process.env.NODE_ENV !== "production") {
             throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(15) : "selectSlice returned undefined for an uninjected slice reducer");
           }
@@ -29526,17 +29541,13 @@ function buildCreateSlice({
         return sliceState;
       }
       function getSelectors(selectState = selectSelf) {
-        const selectorCache = emplace(injectedSelectorCache, injected, {
-          insert: () => /* @__PURE__ */ new WeakMap()
-        });
-        return emplace(selectorCache, selectState, {
-          insert: () => {
-            const map = {};
-            for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
-              map[name2] = wrapSelector(selector, selectState, getInitialState, injected);
-            }
-            return map;
+        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
+        return getOrInsertComputed(selectorCache, selectState, () => {
+          const map = {};
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
+            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
           }
+          return map;
         });
       }
       return {
@@ -29706,6 +29717,24 @@ function formatProdErrorMessage2(code) {
   return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
 }
 
+// ../../node_modules/@standard-schema/utils/dist/index.js
+var SchemaError = class extends Error {
+  /**
+   * Creates a schema error with useful information.
+   *
+   * @param issues The schema issues.
+   */
+  constructor(issues) {
+    super(issues[0].message);
+    /**
+     * The schema issues.
+     */
+    __publicField(this, "issues");
+    this.name = "SchemaError";
+    this.issues = issues;
+  }
+};
+
 // ../../node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.mjs
 var QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {
   QueryStatus2["uninitialized"] = "uninitialized";
@@ -29779,6 +29808,10 @@ function joinUrls(base, url) {
   url = withoutLeadingSlash(url);
   return `${base}${delimiter}${url}`;
 }
+function getOrInsert(map, key, value) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, value).get(key);
+}
 var defaultFetchFn = (...args) => fetch(...args);
 var defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;
 var defaultIsJsonContentType = (headers) => (
@@ -29956,9 +29989,15 @@ function isQueryDefinition(e) {
 function isMutationDefinition(e) {
   return e.type === "mutation";
 }
+function isInfiniteQueryDefinition(e) {
+  return e.type === "infinitequery";
+}
+function isAnyQueryDefinition(e) {
+  return isQueryDefinition(e) || isInfiniteQueryDefinition(e);
+}
 function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
   if (isFunction(description)) {
-    return description(result, error, queryArg, meta).map(expandTagDescription).map(assertTagTypes);
+    return description(result, error, queryArg, meta).filter(isNotNullish).map(expandTagDescription).map(assertTagTypes);
   }
   if (Array.isArray(description)) {
     return description.map(expandTagDescription).map(assertTagTypes);
@@ -29981,6 +30020,7 @@ var isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === "function";
 function buildInitiate({
   serializeQueryArgs,
   queryThunk,
+  infiniteQueryThunk,
   mutationThunk,
   api,
   context
@@ -29994,6 +30034,7 @@ function buildInitiate({
   } = api.internalActions;
   return {
     buildInitiateQuery,
+    buildInitiateInfiniteQuery,
     buildInitiateMutation,
     getRunningQueryThunk,
     getRunningMutationThunk,
@@ -30033,7 +30074,7 @@ You must add the middleware for RTK-Query to function correctly!`);
       }
     }
   }
-  function buildInitiateQuery(endpointName, endpointDefinition) {
+  function buildInitiateAnyQuery(endpointName, endpointDefinition) {
     const queryAction = (arg, {
       subscribe = true,
       forceRefetch,
@@ -30046,7 +30087,8 @@ You must add the middleware for RTK-Query to function correctly!`);
         endpointDefinition,
         endpointName
       });
-      const thunk2 = queryThunk({
+      let thunk2;
+      const commonThunkArgs = {
         ...rest,
         type: "query",
         subscribe,
@@ -30056,7 +30098,22 @@ You must add the middleware for RTK-Query to function correctly!`);
         originalArgs: arg,
         queryCacheKey,
         [forceQueryFnSymbol]: forceQueryFn
-      });
+      };
+      if (isQueryDefinition(endpointDefinition)) {
+        thunk2 = queryThunk(commonThunkArgs);
+      } else {
+        const {
+          direction,
+          initialPageParam
+        } = rest;
+        thunk2 = infiniteQueryThunk({
+          ...commonThunkArgs,
+          // Supply these even if undefined. This helps with a field existence
+          // check over in `buildSlice.ts`
+          direction,
+          initialPageParam
+        });
+      }
       const selector = api.endpoints[endpointName].select(arg);
       const thunkResult = dispatch(thunk2);
       const stateAfter = selector(getState());
@@ -30114,9 +30171,8 @@ You must add the middleware for RTK-Query to function correctly!`);
         }
       });
       if (!runningQuery && !skippedSynchronously && !forceQueryFn) {
-        const running = runningQueries.get(dispatch) || {};
+        const running = getOrInsert(runningQueries, dispatch, {});
         running[queryCacheKey] = statePromise;
-        runningQueries.set(dispatch, running);
         statePromise.then(() => {
           delete running[queryCacheKey];
           if (!countObjectKeys(running)) {
@@ -30128,6 +30184,14 @@ You must add the middleware for RTK-Query to function correctly!`);
     };
     return queryAction;
   }
+  function buildInitiateQuery(endpointName, endpointDefinition) {
+    const queryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
+    return queryAction;
+  }
+  function buildInitiateInfiniteQuery(endpointName, endpointDefinition) {
+    const infiniteQueryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
+    return infiniteQueryAction;
+  }
   function buildInitiateMutation(endpointName) {
     return (arg, {
       track = true,
@@ -30189,9 +30253,30 @@ You must add the middleware for RTK-Query to function correctly!`);
     };
   }
 }
+var NamedSchemaError = class extends SchemaError {
+  constructor(issues, value, schemaName, _bqMeta) {
+    super(issues);
+    this.value = value;
+    this.schemaName = schemaName;
+    this._bqMeta = _bqMeta;
+  }
+};
+async function parseWithSchema(schema, data, schemaName, bqMeta) {
+  const result = await schema["~standard"].validate(data);
+  if (result.issues) {
+    throw new NamedSchemaError(result.issues, data, schemaName, bqMeta);
+  }
+  return result.value;
+}
 function defaultTransformResponse(baseQueryReturnValue) {
   return baseQueryReturnValue;
 }
+var addShouldAutoBatch = (arg = {}) => {
+  return {
+    ...arg,
+    [SHOULD_AUTOBATCH]: true
+  };
+};
 function buildThunks({
   reducerPath,
   baseQuery,
@@ -30200,7 +30285,11 @@ function buildThunks({
   },
   serializeQueryArgs,
   api,
-  assertTagType
+  assertTagType,
+  selectors,
+  onSchemaFailure,
+  catchSchemaFailure: globalCatchSchemaFailure,
+  skipSchemaValidation: globalSkipSchemaValidation
 }) {
   const patchQueryData = (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
     const endpointDefinition = endpointDefinitions[endpointName];
@@ -30221,11 +30310,19 @@ function buildThunks({
       getState()
     );
     const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, arg, {}, assertTagType);
-    dispatch(api.internalActions.updateProvidedBy({
+    dispatch(api.internalActions.updateProvidedBy([{
       queryCacheKey,
       providedTags
-    }));
+    }]));
   };
+  function addToStart(items, item, max = 0) {
+    const newItems = [item, ...items];
+    return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+  }
+  function addToEnd(items, item, max = 0) {
+    const newItems = [...items, item];
+    return max && newItems.length > max ? newItems.slice(1) : newItems;
+  }
   const updateQueryData = (endpointName, arg, updateRecipe, updateProvided = true) => (dispatch, getState) => {
     const endpointDefinition = api.endpoints[endpointName];
     const currentState = endpointDefinition.select(arg)(
@@ -30268,13 +30365,17 @@ function buildThunks({
     return ret;
   };
   const upsertQueryData = (endpointName, arg, value) => (dispatch) => {
-    return dispatch(api.endpoints[endpointName].initiate(arg, {
+    const res = dispatch(api.endpoints[endpointName].initiate(arg, {
       subscribe: false,
       forceRefetch: true,
       [forceQueryFnSymbol]: () => ({
         data: value
       })
     }));
+    return res;
+  };
+  const getTransformCallbackForEndpoint = (endpointDefinition, transformFieldName) => {
+    return endpointDefinition.query && endpointDefinition[transformFieldName] ? endpointDefinition[transformFieldName] : defaultTransformResponse;
   };
   const executeEndpoint = async (arg, {
     signal,
@@ -30286,9 +30387,12 @@ function buildThunks({
     extra
   }) => {
     const endpointDefinition = endpointDefinitions[arg.endpointName];
+    const {
+      metaSchema,
+      skipSchemaValidation = globalSkipSchemaValidation
+    } = endpointDefinition;
     try {
-      let transformResponse = defaultTransformResponse;
-      let result;
+      let transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
       const baseQueryApi = {
         signal,
         abort,
@@ -30301,76 +30405,209 @@ function buildThunks({
         queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
       };
       const forceQueryFn = arg.type === "query" ? arg[forceQueryFnSymbol] : void 0;
-      if (forceQueryFn) {
-        result = forceQueryFn();
-      } else if (endpointDefinition.query) {
-        result = await baseQuery(endpointDefinition.query(arg.originalArgs), baseQueryApi, endpointDefinition.extraOptions);
-        if (endpointDefinition.transformResponse) {
-          transformResponse = endpointDefinition.transformResponse;
+      let finalQueryReturnValue;
+      const fetchPage = async (data, param, maxPages, previous) => {
+        if (param == null && data.pages.length) {
+          return Promise.resolve({
+            data
+          });
         }
-      } else {
-        result = await endpointDefinition.queryFn(arg.originalArgs, baseQueryApi, endpointDefinition.extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, endpointDefinition.extraOptions));
-      }
-      if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
-        const what = endpointDefinition.query ? "`baseQuery`" : "`queryFn`";
-        let err;
-        if (!result) {
-          err = `${what} did not return anything.`;
-        } else if (typeof result !== "object") {
-          err = `${what} did not return an object.`;
-        } else if (result.error && result.data) {
-          err = `${what} returned an object containing both \`error\` and \`result\`.`;
-        } else if (result.error === void 0 && result.data === void 0) {
-          err = `${what} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
+        const finalQueryArg = {
+          queryArg: arg.originalArgs,
+          pageParam: param
+        };
+        const pageResponse = await executeRequest(finalQueryArg);
+        const addTo = previous ? addToStart : addToEnd;
+        return {
+          data: {
+            pages: addTo(data.pages, pageResponse.data, maxPages),
+            pageParams: addTo(data.pageParams, param, maxPages)
+          },
+          meta: pageResponse.meta
+        };
+      };
+      async function executeRequest(finalQueryArg) {
+        let result;
+        const {
+          extraOptions,
+          argSchema,
+          rawResponseSchema,
+          responseSchema
+        } = endpointDefinition;
+        if (argSchema && !skipSchemaValidation) {
+          finalQueryArg = await parseWithSchema(
+            argSchema,
+            finalQueryArg,
+            "argSchema",
+            {}
+            // we don't have a meta yet, so we can't pass it
+          );
+        }
+        if (forceQueryFn) {
+          result = forceQueryFn();
+        } else if (endpointDefinition.query) {
+          result = await baseQuery(endpointDefinition.query(finalQueryArg), baseQueryApi, extraOptions);
         } else {
-          for (const key of Object.keys(result)) {
-            if (key !== "error" && key !== "data" && key !== "meta") {
-              err = `The object returned by ${what} has the unknown property ${key}.`;
-              break;
+          result = await endpointDefinition.queryFn(finalQueryArg, baseQueryApi, extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, extraOptions));
+        }
+        if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+          const what = endpointDefinition.query ? "`baseQuery`" : "`queryFn`";
+          let err;
+          if (!result) {
+            err = `${what} did not return anything.`;
+          } else if (typeof result !== "object") {
+            err = `${what} did not return an object.`;
+          } else if (result.error && result.data) {
+            err = `${what} returned an object containing both \`error\` and \`result\`.`;
+          } else if (result.error === void 0 && result.data === void 0) {
+            err = `${what} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
+          } else {
+            for (const key of Object.keys(result)) {
+              if (key !== "error" && key !== "data" && key !== "meta") {
+                err = `The object returned by ${what} has the unknown property ${key}.`;
+                break;
+              }
             }
           }
+          if (err) {
+            console.error(`Error encountered handling the endpoint ${arg.endpointName}.
+                  ${err}
+                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
+                  Object returned was:`, result);
+          }
+        }
+        if (result.error) throw new HandledError(result.error, result.meta);
+        let {
+          data
+        } = result;
+        if (rawResponseSchema && !skipSchemaValidation) {
+          data = await parseWithSchema(rawResponseSchema, result.data, "rawResponseSchema", result.meta);
         }
-        if (err) {
-          console.error(`Error encountered handling the endpoint ${arg.endpointName}.
-              ${err}
-              It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
-              Object returned was:`, result);
+        let transformedResponse = await transformResponse(data, result.meta, finalQueryArg);
+        if (responseSchema && !skipSchemaValidation) {
+          transformedResponse = await parseWithSchema(responseSchema, transformedResponse, "responseSchema", result.meta);
+        }
+        return {
+          ...result,
+          data: transformedResponse
+        };
+      }
+      if (arg.type === "query" && "infiniteQueryOptions" in endpointDefinition) {
+        const {
+          infiniteQueryOptions
+        } = endpointDefinition;
+        const {
+          maxPages = Infinity
+        } = infiniteQueryOptions;
+        let result;
+        const blankData = {
+          pages: [],
+          pageParams: []
+        };
+        const cachedData = selectors.selectQueryEntry(getState(), arg.queryCacheKey)?.data;
+        const isForcedQueryNeedingRefetch = (
+          // arg.forceRefetch
+          isForcedQuery(arg, getState()) && !arg.direction
+        );
+        const existingData = isForcedQueryNeedingRefetch || !cachedData ? blankData : cachedData;
+        if ("direction" in arg && arg.direction && existingData.pages.length) {
+          const previous = arg.direction === "backward";
+          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+          const param = pageParamFn(infiniteQueryOptions, existingData);
+          result = await fetchPage(existingData, param, maxPages, previous);
+        } else {
+          const {
+            initialPageParam = infiniteQueryOptions.initialPageParam
+          } = arg;
+          const cachedPageParams = cachedData?.pageParams ?? [];
+          const firstPageParam = cachedPageParams[0] ?? initialPageParam;
+          const totalPages = cachedPageParams.length;
+          result = await fetchPage(existingData, firstPageParam, maxPages);
+          if (forceQueryFn) {
+            result = {
+              data: result.data.pages[0]
+            };
+          }
+          for (let i = 1; i < totalPages; i++) {
+            const param = getNextPageParam(infiniteQueryOptions, result.data);
+            result = await fetchPage(result.data, param, maxPages);
+          }
         }
+        finalQueryReturnValue = result;
+      } else {
+        finalQueryReturnValue = await executeRequest(arg.originalArgs);
       }
-      if (result.error) throw new HandledError(result.error, result.meta);
-      return fulfillWithValue(await transformResponse(result.data, result.meta, arg.originalArgs), {
+      if (metaSchema && !skipSchemaValidation && finalQueryReturnValue.meta) {
+        finalQueryReturnValue.meta = await parseWithSchema(metaSchema, finalQueryReturnValue.meta, "metaSchema", finalQueryReturnValue.meta);
+      }
+      return fulfillWithValue(finalQueryReturnValue.data, addShouldAutoBatch({
         fulfilledTimeStamp: Date.now(),
-        baseQueryMeta: result.meta,
-        [SHOULD_AUTOBATCH]: true
-      });
+        baseQueryMeta: finalQueryReturnValue.meta
+      }));
     } catch (error) {
-      let catchedError = error;
-      if (catchedError instanceof HandledError) {
-        let transformErrorResponse = defaultTransformResponse;
-        if (endpointDefinition.query && endpointDefinition.transformErrorResponse) {
-          transformErrorResponse = endpointDefinition.transformErrorResponse;
-        }
+      let caughtError = error;
+      if (caughtError instanceof HandledError) {
+        let transformErrorResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformErrorResponse");
+        const {
+          rawErrorResponseSchema,
+          errorResponseSchema
+        } = endpointDefinition;
+        let {
+          value,
+          meta
+        } = caughtError;
         try {
-          return rejectWithValue(await transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs), {
-            baseQueryMeta: catchedError.meta,
-            [SHOULD_AUTOBATCH]: true
-          });
+          if (rawErrorResponseSchema && !skipSchemaValidation) {
+            value = await parseWithSchema(rawErrorResponseSchema, value, "rawErrorResponseSchema", meta);
+          }
+          if (metaSchema && !skipSchemaValidation) {
+            meta = await parseWithSchema(metaSchema, meta, "metaSchema", meta);
+          }
+          let transformedErrorResponse = await transformErrorResponse(value, meta, arg.originalArgs);
+          if (errorResponseSchema && !skipSchemaValidation) {
+            transformedErrorResponse = await parseWithSchema(errorResponseSchema, transformedErrorResponse, "errorResponseSchema", meta);
+          }
+          return rejectWithValue(transformedErrorResponse, addShouldAutoBatch({
+            baseQueryMeta: meta
+          }));
         } catch (e) {
-          catchedError = e;
+          caughtError = e;
+        }
+      }
+      try {
+        if (caughtError instanceof NamedSchemaError) {
+          const info = {
+            endpoint: arg.endpointName,
+            arg: arg.originalArgs,
+            type: arg.type,
+            queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+          };
+          endpointDefinition.onSchemaFailure?.(caughtError, info);
+          onSchemaFailure?.(caughtError, info);
+          const {
+            catchSchemaFailure = globalCatchSchemaFailure
+          } = endpointDefinition;
+          if (catchSchemaFailure) {
+            return rejectWithValue(catchSchemaFailure(caughtError, info), addShouldAutoBatch({
+              baseQueryMeta: caughtError._bqMeta
+            }));
+          }
         }
+      } catch (e) {
+        caughtError = e;
       }
       if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
         console.error(`An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
-In the case of an unhandled error, no tags will be "provided" or "invalidated".`, catchedError);
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, caughtError);
       } else {
-        console.error(catchedError);
+        console.error(caughtError);
       }
-      throw catchedError;
+      throw caughtError;
     }
   };
   function isForcedQuery(arg, state) {
-    const requestState = state[reducerPath]?.queries?.[arg.queryCacheKey];
-    const baseFetchOnMountOrArgChange = state[reducerPath]?.config.refetchOnMountOrArgChange;
+    const requestState = selectors.selectQueryEntry(state, arg.queryCacheKey);
+    const baseFetchOnMountOrArgChange = selectors.selectConfig(state).refetchOnMountOrArgChange;
     const fulfilledVal = requestState?.fulfilledTimeStamp;
     const refetchVal = arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange);
     if (refetchVal) {
@@ -30378,52 +30615,62 @@ In the case of an unhandled error, no tags will be "provided" or "invalidated".`
     }
     return false;
   }
-  const queryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {
-    getPendingMeta() {
-      return {
-        startedTimeStamp: Date.now(),
-        [SHOULD_AUTOBATCH]: true
-      };
-    },
-    condition(queryThunkArgs, {
-      getState
-    }) {
-      const state = getState();
-      const requestState = state[reducerPath]?.queries?.[queryThunkArgs.queryCacheKey];
-      const fulfilledVal = requestState?.fulfilledTimeStamp;
-      const currentArg = queryThunkArgs.originalArgs;
-      const previousArg = requestState?.originalArgs;
-      const endpointDefinition = endpointDefinitions[queryThunkArgs.endpointName];
-      if (isUpsertQuery(queryThunkArgs)) {
-        return true;
-      }
-      if (requestState?.status === "pending") {
-        return false;
-      }
-      if (isForcedQuery(queryThunkArgs, state)) {
-        return true;
-      }
-      if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({
-        currentArg,
-        previousArg,
-        endpointState: requestState,
-        state
-      })) {
+  const createQueryThunk = () => {
+    const generatedQueryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {
+      getPendingMeta({
+        arg
+      }) {
+        const endpointDefinition = endpointDefinitions[arg.endpointName];
+        return addShouldAutoBatch({
+          startedTimeStamp: Date.now(),
+          ...isInfiniteQueryDefinition(endpointDefinition) ? {
+            direction: arg.direction
+          } : {}
+        });
+      },
+      condition(queryThunkArg, {
+        getState
+      }) {
+        const state = getState();
+        const requestState = selectors.selectQueryEntry(state, queryThunkArg.queryCacheKey);
+        const fulfilledVal = requestState?.fulfilledTimeStamp;
+        const currentArg = queryThunkArg.originalArgs;
+        const previousArg = requestState?.originalArgs;
+        const endpointDefinition = endpointDefinitions[queryThunkArg.endpointName];
+        const direction = queryThunkArg.direction;
+        if (isUpsertQuery(queryThunkArg)) {
+          return true;
+        }
+        if (requestState?.status === "pending") {
+          return false;
+        }
+        if (isForcedQuery(queryThunkArg, state)) {
+          return true;
+        }
+        if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({
+          currentArg,
+          previousArg,
+          endpointState: requestState,
+          state
+        })) {
+          return true;
+        }
+        if (fulfilledVal && !direction) {
+          return false;
+        }
         return true;
-      }
-      if (fulfilledVal) {
-        return false;
-      }
-      return true;
-    },
-    dispatchConditionRejection: true
-  });
+      },
+      dispatchConditionRejection: true
+    });
+    return generatedQueryThunk;
+  };
+  const queryThunk = createQueryThunk();
+  const infiniteQueryThunk = createQueryThunk();
   const mutationThunk = createAsyncThunk(`${reducerPath}/executeMutation`, executeEndpoint, {
     getPendingMeta() {
-      return {
-        startedTimeStamp: Date.now(),
-        [SHOULD_AUTOBATCH]: true
-      };
+      return addShouldAutoBatch({
+        startedTimeStamp: Date.now()
+      });
     }
   });
   const hasTheForce = (options) => "force" in options;
@@ -30468,6 +30715,7 @@ In the case of an unhandled error, no tags will be "provided" or "invalidated".`
   return {
     queryThunk,
     mutationThunk,
+    infiniteQueryThunk,
     prefetch,
     updateQueryData,
     upsertQueryData,
@@ -30475,6 +30723,19 @@ In the case of an unhandled error, no tags will be "provided" or "invalidated".`
     buildMatchThunkActions
   };
 }
+function getNextPageParam(options, {
+  pages,
+  pageParams
+}) {
+  const lastIndex = pages.length - 1;
+  return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
+}
+function getPreviousPageParam(options, {
+  pages,
+  pageParams
+}) {
+  return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
+}
 function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
   return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, "baseQueryMeta" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);
 }
@@ -30528,11 +30789,16 @@ function buildSlice({
         substate.originalArgs = arg.originalArgs;
       }
       substate.startedTimeStamp = meta.startedTimeStamp;
+      const endpointDefinition = definitions[meta.arg.endpointName];
+      if (isInfiniteQueryDefinition(endpointDefinition) && "direction" in arg) {
+        ;
+        substate.direction = arg.direction;
+      }
     });
   }
-  function writeFulfilledCacheEntry(draft, meta, payload) {
+  function writeFulfilledCacheEntry(draft, meta, payload, upserting) {
     updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, (substate) => {
-      if (substate.requestId !== meta.requestId && !isUpsertQuery(meta.arg)) return;
+      if (substate.requestId !== meta.requestId && !upserting) return;
       const {
         merge
       } = definitions[meta.arg.endpointName];
@@ -30590,12 +30856,18 @@ function buildSlice({
               requestId: action.meta.requestId,
               startedTimeStamp: action.meta.timestamp
             });
-            writeFulfilledCacheEntry(draft, {
-              arg,
-              requestId: action.meta.requestId,
-              fulfilledTimeStamp: action.meta.timestamp,
-              baseQueryMeta: {}
-            }, value);
+            writeFulfilledCacheEntry(
+              draft,
+              {
+                arg,
+                requestId: action.meta.requestId,
+                fulfilledTimeStamp: action.meta.timestamp,
+                baseQueryMeta: {}
+              },
+              value,
+              // We know we're upserting here
+              true
+            );
           }
         },
         prepare: (payload) => {
@@ -30659,7 +30931,8 @@ function buildSlice({
         meta,
         payload
       }) => {
-        writeFulfilledCacheEntry(draft, meta, payload);
+        const upserting = isUpsertQuery(meta.arg);
+        writeFulfilledCacheEntry(draft, meta, payload, upserting);
       }).addCase(queryThunk.rejected, (draft, {
         meta: {
           condition,
@@ -30762,34 +31035,33 @@ function buildSlice({
       });
     }
   });
+  const initialInvalidationState = {
+    tags: {},
+    keys: {}
+  };
   const invalidationSlice = createSlice({
     name: `${reducerPath}/invalidation`,
-    initialState,
+    initialState: initialInvalidationState,
     reducers: {
       updateProvidedBy: {
         reducer(draft, action) {
-          var _a, _b;
-          const {
+          var _a, _b, _c;
+          for (const {
             queryCacheKey,
             providedTags
-          } = action.payload;
-          for (const tagTypeSubscriptions of Object.values(draft)) {
-            for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {
-              const foundAt = idSubscriptions.indexOf(queryCacheKey);
-              if (foundAt !== -1) {
-                idSubscriptions.splice(foundAt, 1);
+          } of action.payload) {
+            removeCacheKeyFromTags(draft, queryCacheKey);
+            for (const {
+              type,
+              id
+            } of providedTags) {
+              const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
+              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
+              if (!alreadySubscribed) {
+                subscribedQueries.push(queryCacheKey);
               }
             }
-          }
-          for (const {
-            type,
-            id
-          } of providedTags) {
-            const subscribedQueries = (_a = draft[type] ?? (draft[type] = {}))[_b = id || "__internal_without_id"] ?? (_a[_b] = []);
-            const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
-            if (!alreadySubscribed) {
-              subscribedQueries.push(queryCacheKey);
-            }
+            draft.keys[queryCacheKey] = providedTags;
           }
         },
         prepare: prepareAutoBatched()
@@ -30801,22 +31073,15 @@ function buildSlice({
           queryCacheKey
         }
       }) => {
-        for (const tagTypeSubscriptions of Object.values(draft)) {
-          for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {
-            const foundAt = idSubscriptions.indexOf(queryCacheKey);
-            if (foundAt !== -1) {
-              idSubscriptions.splice(foundAt, 1);
-            }
-          }
-        }
+        removeCacheKeyFromTags(draft, queryCacheKey);
       }).addMatcher(hasRehydrationInfo, (draft, action) => {
-        var _a, _b;
+        var _a, _b, _c;
         const {
           provided
         } = extractRehydrationInfo(action);
         for (const [type, incomingTags] of Object.entries(provided)) {
           for (const [id, cacheKeys] of Object.entries(incomingTags)) {
-            const subscribedQueries = (_a = draft[type] ?? (draft[type] = {}))[_b = id || "__internal_without_id"] ?? (_a[_b] = []);
+            const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
             for (const queryCacheKey of cacheKeys) {
               const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
               if (!alreadySubscribed) {
@@ -30826,17 +31091,51 @@ function buildSlice({
           }
         }
       }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {
-        const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
-        const {
-          queryCacheKey
-        } = action.meta.arg;
-        invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy({
-          queryCacheKey,
-          providedTags
-        }));
+        writeProvidedTagsForQueries(draft, [action]);
+      }).addMatcher(querySlice.actions.cacheEntriesUpserted.match, (draft, action) => {
+        const mockActions = action.payload.map(({
+          queryDescription,
+          value
+        }) => {
+          return {
+            type: "UNKNOWN",
+            payload: value,
+            meta: {
+              requestStatus: "fulfilled",
+              requestId: "UNKNOWN",
+              arg: queryDescription
+            }
+          };
+        });
+        writeProvidedTagsForQueries(draft, mockActions);
       });
     }
   });
+  function removeCacheKeyFromTags(draft, queryCacheKey) {
+    const existingTags = draft.keys[queryCacheKey] ?? [];
+    for (const tag of existingTags) {
+      const tagType = tag.type;
+      const tagId = tag.id ?? "__internal_without_id";
+      const tagSubscriptions = draft.tags[tagType]?.[tagId];
+      if (tagSubscriptions) {
+        draft.tags[tagType][tagId] = tagSubscriptions.filter((qc) => qc !== queryCacheKey);
+      }
+    }
+    delete draft.keys[queryCacheKey];
+  }
+  function writeProvidedTagsForQueries(draft, actions2) {
+    const providedByEntries = actions2.map((action) => {
+      const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
+      const {
+        queryCacheKey
+      } = action.meta.arg;
+      return {
+        queryCacheKey,
+        providedTags
+      };
+    });
+    invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy(providedByEntries));
+  }
   const subscriptionSlice = createSlice({
     name: `${reducerPath}/subscriptions`,
     initialState,
@@ -30930,9 +31229,15 @@ function buildSelectors({
   const selectSkippedMutation = (state) => defaultMutationSubState;
   return {
     buildQuerySelector,
+    buildInfiniteQuerySelector,
     buildMutationSelector,
     selectInvalidatedBy,
-    selectCachedArgsForQuery
+    selectCachedArgsForQuery,
+    selectApiState,
+    selectQueries,
+    selectMutations,
+    selectQueryEntry,
+    selectConfig
   };
   function withRequestFlags(substate) {
     return {
@@ -30940,29 +31245,74 @@ function buildSelectors({
       ...getRequestStatusFlags(substate.status)
     };
   }
-  function selectInternalState(rootState) {
+  function selectApiState(rootState) {
     const state = rootState[reducerPath];
     if (process.env.NODE_ENV !== "production") {
       if (!state) {
-        if (selectInternalState.triggered) return state;
-        selectInternalState.triggered = true;
+        if (selectApiState.triggered) return state;
+        selectApiState.triggered = true;
         console.error(`Error: No data found at \`state.${reducerPath}\`. Did you forget to add the reducer to the store?`);
       }
     }
     return state;
   }
-  function buildQuerySelector(endpointName, endpointDefinition) {
+  function selectQueries(rootState) {
+    return selectApiState(rootState)?.queries;
+  }
+  function selectQueryEntry(rootState, cacheKey) {
+    return selectQueries(rootState)?.[cacheKey];
+  }
+  function selectMutations(rootState) {
+    return selectApiState(rootState)?.mutations;
+  }
+  function selectConfig(rootState) {
+    return selectApiState(rootState)?.config;
+  }
+  function buildAnyQuerySelector(endpointName, endpointDefinition, combiner) {
     return (queryArgs) => {
+      if (queryArgs === skipToken) {
+        return createSelector2(selectSkippedQuery, combiner);
+      }
       const serializedArgs = serializeQueryArgs({
         queryArgs,
         endpointDefinition,
         endpointName
       });
-      const selectQuerySubstate = (state) => selectInternalState(state)?.queries?.[serializedArgs] ?? defaultQuerySubState;
-      const finalSelectQuerySubState = queryArgs === skipToken ? selectSkippedQuery : selectQuerySubstate;
-      return createSelector2(finalSelectQuerySubState, withRequestFlags);
+      const selectQuerySubstate = (state) => selectQueryEntry(state, serializedArgs) ?? defaultQuerySubState;
+      return createSelector2(selectQuerySubstate, combiner);
     };
   }
+  function buildQuerySelector(endpointName, endpointDefinition) {
+    return buildAnyQuerySelector(endpointName, endpointDefinition, withRequestFlags);
+  }
+  function buildInfiniteQuerySelector(endpointName, endpointDefinition) {
+    const {
+      infiniteQueryOptions
+    } = endpointDefinition;
+    function withInfiniteQueryResultFlags(substate) {
+      const stateWithRequestFlags = {
+        ...substate,
+        ...getRequestStatusFlags(substate.status)
+      };
+      const {
+        isLoading,
+        isError: isError2,
+        direction
+      } = stateWithRequestFlags;
+      const isForward = direction === "forward";
+      const isBackward = direction === "backward";
+      return {
+        ...stateWithRequestFlags,
+        hasNextPage: getHasNextPage(infiniteQueryOptions, stateWithRequestFlags.data),
+        hasPreviousPage: getHasPreviousPage(infiniteQueryOptions, stateWithRequestFlags.data),
+        isFetchingNextPage: isLoading && isForward,
+        isFetchingPreviousPage: isLoading && isBackward,
+        isFetchNextPageError: isError2 && isForward,
+        isFetchPreviousPageError: isError2 && isBackward
+      };
+    }
+    return buildAnyQuerySelector(endpointName, endpointDefinition, withInfiniteQueryResultFlags);
+  }
   function buildMutationSelector() {
     return (id) => {
       let mutationId;
@@ -30971,7 +31321,7 @@ function buildSelectors({
       } else {
         mutationId = id;
       }
-      const selectMutationSubstate = (state) => selectInternalState(state)?.mutations?.[mutationId] ?? defaultMutationSubState;
+      const selectMutationSubstate = (state) => selectApiState(state)?.mutations?.[mutationId] ?? defaultMutationSubState;
       const finalSelectMutationSubstate = mutationId === skipToken ? selectSkippedMutation : selectMutationSubstate;
       return createSelector2(finalSelectMutationSubstate, withRequestFlags);
     };
@@ -30979,8 +31329,8 @@ function buildSelectors({
   function selectInvalidatedBy(state, tags) {
     const apiState = state[reducerPath];
     const toInvalidate = /* @__PURE__ */ new Set();
-    for (const tag of tags.map(expandTagDescription)) {
-      const provided = apiState.provided[tag.type];
+    for (const tag of tags.filter(isNotNullish).map(expandTagDescription)) {
+      const provided = apiState.provided.tags[tag.type];
       if (!provided) {
         continue;
       }
@@ -31005,11 +31355,19 @@ function buildSelectors({
     }));
   }
   function selectCachedArgsForQuery(state, queryName) {
-    return Object.values(state[reducerPath].queries).filter(
+    return Object.values(selectQueries(state)).filter(
       (entry) => entry?.endpointName === queryName && entry.status !== "uninitialized"
       /* uninitialized */
     ).map((entry) => entry.originalArgs);
   }
+  function getHasNextPage(options, data) {
+    if (!data) return false;
+    return getNextPageParam(options, data) != null;
+  }
+  function getHasPreviousPage(options, data) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return getPreviousPageParam(options, data) != null;
+  }
 }
 var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
 var defaultSerializeQueryArgs = ({
@@ -31121,6 +31479,11 @@ function buildCreateApi(...modules) {
           ...x,
           type: "mutation"
           /* mutation */
+        }),
+        infiniteQuery: (x) => ({
+          ...x,
+          type: "infinitequery"
+          /* infinitequery */
         })
       });
       for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {
@@ -31132,6 +31495,25 @@ function buildCreateApi(...modules) {
           }
           continue;
         }
+        if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+          if (isInfiniteQueryDefinition(definition)) {
+            const {
+              infiniteQueryOptions
+            } = definition;
+            const {
+              maxPages,
+              getPreviousPageParam: getPreviousPageParam2
+            } = infiniteQueryOptions;
+            if (typeof maxPages === "number") {
+              if (maxPages < 1) {
+                throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(40) : `maxPages for endpoint '${endpointName}' must be a number greater than 0`);
+              }
+              if (typeof getPreviousPageParam2 !== "function") {
+                throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(41) : `getPreviousPageParam for endpoint '${endpointName}' must be a function if maxPages is used`);
+              }
+            }
+          }
+        }
         context.endpointDefinitions[endpointName] = definition;
         for (const m of initializedModules) {
           m.injectEndpoint(endpointName, definition);
@@ -31283,7 +31665,11 @@ var buildCacheCollectionHandler = ({
   api,
   queryThunk,
   context,
-  internalState
+  internalState,
+  selectors: {
+    selectQueryEntry,
+    selectConfig
+  }
 }) => {
   const {
     removeQueryResult,
@@ -31297,8 +31683,9 @@ var buildCacheCollectionHandler = ({
   }
   const currentRemovalTimeouts = {};
   const handler = (action, mwApi, internalState2) => {
+    const state = mwApi.getState();
+    const config = selectConfig(state);
     if (canTriggerUnsubscribe(action)) {
-      const state = mwApi.getState()[reducerPath];
       let queryCacheKeys;
       if (cacheEntriesUpserted.match(action)) {
         queryCacheKeys = action.payload.map((entry) => entry.queryDescription.queryCacheKey);
@@ -31308,9 +31695,7 @@ var buildCacheCollectionHandler = ({
         } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;
         queryCacheKeys = [queryCacheKey];
       }
-      for (const queryCacheKey of queryCacheKeys) {
-        handleUnsubscribe(queryCacheKey, state.queries[queryCacheKey]?.endpointName, mwApi, state.config);
-      }
+      handleUnsubscribeMany(queryCacheKeys, mwApi, config);
     }
     if (api.util.resetApiState.match(action)) {
       for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {
@@ -31319,15 +31704,19 @@ var buildCacheCollectionHandler = ({
       }
     }
     if (context.hasRehydrationInfo(action)) {
-      const state = mwApi.getState()[reducerPath];
       const {
         queries
       } = context.extractRehydrationInfo(action);
-      for (const [queryCacheKey, queryState] of Object.entries(queries)) {
-        handleUnsubscribe(queryCacheKey, queryState?.endpointName, mwApi, state.config);
-      }
+      handleUnsubscribeMany(Object.keys(queries), mwApi, config);
     }
   };
+  function handleUnsubscribeMany(cacheKeys, api2, config) {
+    const state = api2.getState();
+    for (const queryCacheKey of cacheKeys) {
+      const entry = selectQueryEntry(state, queryCacheKey);
+      handleUnsubscribe(queryCacheKey, entry?.endpointName, api2, config);
+    }
+  }
   function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {
     const endpointDefinition = context.endpointDefinitions[endpointName];
     const keepUnusedDataFor = endpointDefinition?.keepUnusedDataFor ?? config.keepUnusedDataFor;
@@ -31359,7 +31748,11 @@ var buildCacheLifecycleHandler = ({
   context,
   queryThunk,
   mutationThunk,
-  internalState
+  internalState,
+  selectors: {
+    selectQueryEntry,
+    selectApiState
+  }
 }) => {
   const isQueryThunk = isAsyncThunkAction(queryThunk);
   const isMutationThunk = isAsyncThunkAction(mutationThunk);
@@ -31385,9 +31778,9 @@ var buildCacheLifecycleHandler = ({
   const handler = (action, mwApi, stateBefore) => {
     const cacheKey = getCacheKey(action);
     function checkForNewCacheKey(endpointName, cacheKey2, requestId, originalArgs) {
-      const oldState = stateBefore[reducerPath].queries[cacheKey2];
-      const state = mwApi.getState()[reducerPath].queries[cacheKey2];
-      if (!oldState && state) {
+      const oldEntry = selectQueryEntry(stateBefore, cacheKey2);
+      const newEntry = selectQueryEntry(mwApi.getState(), cacheKey2);
+      if (!oldEntry && newEntry) {
         handleNewKey(endpointName, originalArgs, cacheKey2, mwApi, requestId);
       }
     }
@@ -31446,14 +31839,14 @@ var buildCacheLifecycleHandler = ({
     cacheDataLoaded.catch(() => {
     });
     lifecycleMap[queryCacheKey] = lifecycle;
-    const selector = api.endpoints[endpointName].select(endpointDefinition.type === "query" ? originalArgs : queryCacheKey);
+    const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : queryCacheKey);
     const extra = mwApi.dispatch((_2, __, extra2) => extra2);
     const lifecycleApi = {
       ...mwApi,
       getCacheEntry: () => selector(mwApi.getState()),
       requestId,
       extra,
-      updateCachedData: endpointDefinition.type === "query" ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+      updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
       cacheDataLoaded,
       cacheEntryRemoved
     };
@@ -31514,11 +31907,14 @@ var buildInvalidationByTagsHandler = ({
     }
   };
   function hasPendingRequests(state) {
-    for (const key in state.queries) {
-      if (state.queries[key]?.status === "pending") return true;
-    }
-    for (const key in state.mutations) {
-      if (state.mutations[key]?.status === "pending") return true;
+    const {
+      queries,
+      mutations
+    } = state;
+    for (const cacheRecord of [queries, mutations]) {
+      for (const key in cacheRecord) {
+        if (cacheRecord[key]?.status === "pending") return true;
+      }
     }
     return false;
   }
@@ -31576,6 +31972,13 @@ var buildPollingHandler = ({
       clearPolls();
     }
   };
+  function getCacheEntrySubscriptions(queryCacheKey, api2) {
+    const state = api2.getState()[reducerPath];
+    const querySubState = state.queries[queryCacheKey];
+    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    if (!querySubState || querySubState.status === "uninitialized") return;
+    return subscriptions;
+  }
   function startNextPoll({
     queryCacheKey
   }, api2) {
@@ -31689,14 +32092,14 @@ var buildQueryLifecycleHandler = ({
         queryFulfilled.catch(() => {
         });
         lifecycleMap[requestId] = lifecycle;
-        const selector = api.endpoints[endpointName].select(endpointDefinition.type === "query" ? originalArgs : requestId);
+        const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : requestId);
         const extra = mwApi.dispatch((_2, __, extra2) => extra2);
         const lifecycleApi = {
           ...mwApi,
           getCacheEntry: () => selector(mwApi.getState()),
           requestId,
           extra,
-          updateCachedData: endpointDefinition.type === "query" ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+          updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
           queryFulfilled
         };
         onQueryStarted(originalArgs, lifecycleApi);
@@ -31856,7 +32259,10 @@ var coreModule = ({
     refetchOnMountOrArgChange,
     refetchOnFocus,
     refetchOnReconnect,
-    invalidationBehavior
+    invalidationBehavior,
+    onSchemaFailure,
+    catchSchemaFailure,
+    skipSchemaValidation
   }, context) {
     enablePatches();
     assertCast(serializeQueryArgs);
@@ -31879,8 +32285,25 @@ var coreModule = ({
       },
       util: {}
     });
+    const selectors = buildSelectors({
+      serializeQueryArgs,
+      reducerPath,
+      createSelector: createSelector2
+    });
+    const {
+      selectInvalidatedBy,
+      selectCachedArgsForQuery,
+      buildQuerySelector,
+      buildInfiniteQuerySelector,
+      buildMutationSelector
+    } = selectors;
+    safeAssign(api.util, {
+      selectInvalidatedBy,
+      selectCachedArgsForQuery
+    });
     const {
       queryThunk,
+      infiniteQueryThunk,
       mutationThunk,
       patchQueryData,
       updateQueryData,
@@ -31893,7 +32316,11 @@ var coreModule = ({
       context,
       api,
       serializeQueryArgs,
-      assertTagType
+      assertTagType,
+      selectors,
+      onSchemaFailure,
+      catchSchemaFailure,
+      skipSchemaValidation
     });
     const {
       reducer,
@@ -31901,6 +32328,7 @@ var coreModule = ({
     } = buildSlice({
       context,
       queryThunk,
+      infiniteQueryThunk,
       mutationThunk,
       serializeQueryArgs,
       reducerPath,
@@ -31931,30 +32359,19 @@ var coreModule = ({
       context,
       queryThunk,
       mutationThunk,
+      infiniteQueryThunk,
       api,
-      assertTagType
+      assertTagType,
+      selectors
     });
     safeAssign(api.util, middlewareActions);
     safeAssign(api, {
       reducer,
       middleware
     });
-    const {
-      buildQuerySelector,
-      buildMutationSelector,
-      selectInvalidatedBy,
-      selectCachedArgsForQuery
-    } = buildSelectors({
-      serializeQueryArgs,
-      reducerPath,
-      createSelector: createSelector2
-    });
-    safeAssign(api.util, {
-      selectInvalidatedBy,
-      selectCachedArgsForQuery
-    });
     const {
       buildInitiateQuery,
+      buildInitiateInfiniteQuery,
       buildInitiateMutation,
       getRunningMutationThunk,
       getRunningMutationsThunk,
@@ -31963,6 +32380,7 @@ var coreModule = ({
     } = buildInitiate({
       queryThunk,
       mutationThunk,
+      infiniteQueryThunk,
       api,
       serializeQueryArgs,
       context
@@ -31978,20 +32396,28 @@ var coreModule = ({
       injectEndpoint(endpointName, definition) {
         var _a;
         const anyApi = api;
-        (_a = anyApi.endpoints)[endpointName] ?? (_a[endpointName] = {});
+        const endpoint = (_a = anyApi.endpoints)[endpointName] ?? (_a[endpointName] = {});
         if (isQueryDefinition(definition)) {
-          safeAssign(anyApi.endpoints[endpointName], {
+          safeAssign(endpoint, {
             name: endpointName,
             select: buildQuerySelector(endpointName, definition),
             initiate: buildInitiateQuery(endpointName, definition)
           }, buildMatchThunkActions(queryThunk, endpointName));
-        } else if (isMutationDefinition(definition)) {
-          safeAssign(anyApi.endpoints[endpointName], {
+        }
+        if (isMutationDefinition(definition)) {
+          safeAssign(endpoint, {
             name: endpointName,
             select: buildMutationSelector(),
             initiate: buildInitiateMutation(endpointName)
           }, buildMatchThunkActions(mutationThunk, endpointName));
         }
+        if (isInfiniteQueryDefinition(definition)) {
+          safeAssign(endpoint, {
+            name: endpointName,
+            select: buildInfiniteQuerySelector(endpointName, definition),
+            initiate: buildInitiateInfiniteQuery(endpointName, definition)
+          }, buildMatchThunkActions(queryThunk, endpointName));
+        }
       }
     };
   }
@@ -32002,59 +32428,35 @@ var createApi = /* @__PURE__ */ buildCreateApi(coreModule());
 import { batch as rrBatch, useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore } from "react-redux";
 import { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from "react";
 import { shallowEqual as shallowEqual2 } from "react-redux";
-import { useEffect, useRef, useMemo } from "react";
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { shallowEqual } from "react-redux";
-import { useContext } from "react";
-import { useEffect as useEffect4 } from "react";
-import * as React from "react";
-import { Provider, ReactReduxContext } from "react-redux";
-function isQueryDefinition2(e) {
-  return e.type === "query";
-}
-function isMutationDefinition2(e) {
-  return e.type === "mutation";
-}
-function safeAssign2(target, ...args) {
-  return Object.assign(target, ...args);
-}
-function capitalize(str) {
-  return str.replace(str[0], str[0].toUpperCase());
-}
-function countObjectKeys2(obj) {
-  let count = 0;
-  for (const _key in obj) {
-    count++;
-  }
-  return count;
-}
-var cache2 = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
-var defaultSerializeQueryArgs2 = ({
-  endpointName,
-  queryArgs
-}) => {
-  let serialized = "";
-  const cached = cache2?.get(queryArgs);
-  if (typeof cached === "string") {
-    serialized = cached;
-  } else {
-    const stringified = JSON.stringify(queryArgs, (key, value) => {
-      value = typeof value === "bigint" ? {
-        $bigint: value.toString()
-      } : value;
-      value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {
-        acc[key2] = value[key2];
-        return acc;
-      }, {}) : value;
-      return value;
-    });
-    if (isPlainObject(queryArgs)) {
-      cache2?.set(queryArgs, stringified);
-    }
-    serialized = stringified;
+import { useEffect, useRef, useMemo } from "react";
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { shallowEqual } from "react-redux";
+import { useContext } from "react";
+import { useEffect as useEffect4 } from "react";
+import * as React from "react";
+import { Provider, ReactReduxContext } from "react-redux";
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+function countObjectKeys2(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
   }
-  return `${endpointName}(${serialized})`;
-};
+  return count;
+}
+function isQueryDefinition2(e) {
+  return e.type === "query";
+}
+function isMutationDefinition2(e) {
+  return e.type === "mutation";
+}
+function isInfiniteQueryDefinition2(e) {
+  return e.type === "infinitequery";
+}
+function safeAssign2(target, ...args) {
+  return Object.assign(target, ...args);
+}
 var UNINITIALIZED_VALUE = Symbol();
 function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
   const incoming = useMemo(() => ({
@@ -32065,22 +32467,22 @@ function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointNa
       endpointName
     }) : queryArgs
   }), [queryArgs, serialize, endpointDefinition, endpointName]);
-  const cache22 = useRef(incoming);
+  const cache2 = useRef(incoming);
   useEffect(() => {
-    if (cache22.current.serialized !== incoming.serialized) {
-      cache22.current = incoming;
+    if (cache2.current.serialized !== incoming.serialized) {
+      cache2.current = incoming;
     }
   }, [incoming]);
-  return cache22.current.serialized === incoming.serialized ? cache22.current.queryArgs : queryArgs;
+  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;
 }
 function useShallowStableValue(value) {
-  const cache22 = useRef2(value);
+  const cache2 = useRef2(value);
   useEffect2(() => {
-    if (!shallowEqual(cache22.current, value)) {
-      cache22.current = value;
+    if (!shallowEqual(cache2.current, value)) {
+      cache2.current = value;
     }
   }, [value]);
-  return shallowEqual(cache22.current, value) ? cache22.current : value;
+  return shallowEqual(cache2.current, value) ? cache2.current : value;
 }
 var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
 var isDOM = /* @__PURE__ */ canUseDOM();
@@ -32100,6 +32502,14 @@ var noPendingQueryStateSelector = (selected) => {
   }
   return selected;
 };
+function pick(obj, ...keys) {
+  const ret = {};
+  keys.forEach((key) => {
+    ret[key] = obj[key];
+  });
+  return ret;
+}
+var COMMON_HOOK_DEBUG_FIELDS = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
 function buildHooks({
   api,
   moduleOptions: {
@@ -32118,6 +32528,7 @@ function buildHooks({
   const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect3;
   return {
     buildQueryHooks,
+    buildInfiniteQueryHooks,
     buildMutationHook,
     usePrefetch
   };
@@ -32127,7 +32538,38 @@ function buildHooks({
         endpointName
       } = lastResult;
       const endpointDefinition = context.endpointDefinitions[endpointName];
-      if (serializeQueryArgs({
+      if (queryArgs !== skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || hasData && (isFetching && !lastResult?.isError || currentState.isUninitialized);
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function infiniteQueryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== skipToken && serializeQueryArgs({
         queryArgs: lastResult.originalArgs,
         endpointDefinition,
         endpointName
@@ -32160,103 +32602,154 @@ function buildHooks({
       ...options
     })), [endpointName, dispatch, stableDefaultOptions]);
   }
-  function buildQueryHooks(name) {
-    const useQuerySubscription = (arg, {
+  function useQuerySubscriptionCommonImpl(endpointName, arg, {
+    refetchOnReconnect,
+    refetchOnFocus,
+    refetchOnMountOrArgChange,
+    skip = false,
+    pollingInterval = 0,
+    skipPollingIfUnfocused = false,
+    ...rest
+  } = {}) {
+    const {
+      initiate
+    } = api.endpoints[endpointName];
+    const dispatch = useDispatch3();
+    const subscriptionSelectorsRef = useRef3(void 0);
+    if (!subscriptionSelectorsRef.current) {
+      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(37) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
+    You must add the middleware for RTK-Query to function correctly!`);
+        }
+      }
+      subscriptionSelectorsRef.current = returnedValue;
+    }
+    const stableArg = useStableQueryArgs(
+      skip ? skipToken : arg,
+      // Even if the user provided a per-endpoint `serializeQueryArgs` with
+      // a consistent return value, _here_ we want to use the default behavior
+      // so we can tell if _anything_ actually changed. Otherwise, we can end up
+      // with a case where the query args did change but the serialization doesn't,
+      // and then we never try to initiate a refetch.
+      defaultSerializeQueryArgs,
+      context.endpointDefinitions[endpointName],
+      endpointName
+    );
+    const stableSubscriptionOptions = useShallowStableValue({
       refetchOnReconnect,
       refetchOnFocus,
-      refetchOnMountOrArgChange,
+      pollingInterval,
+      skipPollingIfUnfocused
+    });
+    const initialPageParam = rest.initialPageParam;
+    const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const promiseRef = useRef3(void 0);
+    let {
+      queryCacheKey,
+      requestId
+    } = promiseRef.current || {};
+    let currentRenderHasSubscription = false;
+    if (queryCacheKey && requestId) {
+      currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+    }
+    const subscriptionRemoved = !currentRenderHasSubscription && promiseRef.current !== void 0;
+    usePossiblyImmediateEffect(() => {
+      if (subscriptionRemoved) {
+        promiseRef.current = void 0;
+      }
+    }, [subscriptionRemoved]);
+    usePossiblyImmediateEffect(() => {
+      const lastPromise = promiseRef.current;
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "removeMeOnCompilation") {
+        console.log(subscriptionRemoved);
+      }
+      if (stableArg === skipToken) {
+        lastPromise?.unsubscribe();
+        promiseRef.current = void 0;
+        return;
+      }
+      const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+      if (!lastPromise || lastPromise.arg !== stableArg) {
+        lastPromise?.unsubscribe();
+        const promise = dispatch(initiate(stableArg, {
+          subscriptionOptions: stableSubscriptionOptions,
+          forceRefetch: refetchOnMountOrArgChange,
+          ...isInfiniteQueryDefinition2(context.endpointDefinitions[endpointName]) ? {
+            initialPageParam: stableInitialPageParam
+          } : {}
+        }));
+        promiseRef.current = promise;
+      } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+        lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+      }
+    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, endpointName]);
+    return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
+  }
+  function buildUseQueryState(endpointName, preSelector) {
+    const useQueryState = (arg, {
       skip = false,
-      pollingInterval = 0,
-      skipPollingIfUnfocused = false
+      selectFromResult
     } = {}) => {
       const {
-        initiate
-      } = api.endpoints[name];
-      const dispatch = useDispatch3();
-      const subscriptionSelectorsRef = useRef3(void 0);
-      if (!subscriptionSelectorsRef.current) {
-        const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
-        if (process.env.NODE_ENV !== "production") {
-          if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
-            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(37) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
-    You must add the middleware for RTK-Query to function correctly!`);
+        select
+      } = api.endpoints[endpointName];
+      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[endpointName], endpointName);
+      const lastValue = useRef3(void 0);
+      const selectDefaultResult = useMemo2(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        createSelector2([
+          // @ts-ignore
+          select(stableArg),
+          (_2, lastResult) => lastResult,
+          (_2) => stableArg
+        ], preSelector, {
+          memoizeOptions: {
+            resultEqualityCheck: shallowEqual2
           }
+        })
+      ), [select, stableArg]);
+      const querySelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
         }
-        subscriptionSelectorsRef.current = returnedValue;
-      }
-      const stableArg = useStableQueryArgs(
-        skip ? skipToken : arg,
-        // Even if the user provided a per-endpoint `serializeQueryArgs` with
-        // a consistent return value, _here_ we want to use the default behavior
-        // so we can tell if _anything_ actually changed. Otherwise, we can end up
-        // with a case where the query args did change but the serialization doesn't,
-        // and then we never try to initiate a refetch.
-        defaultSerializeQueryArgs2,
-        context.endpointDefinitions[name],
-        name
-      );
-      const stableSubscriptionOptions = useShallowStableValue({
-        refetchOnReconnect,
-        refetchOnFocus,
-        pollingInterval,
-        skipPollingIfUnfocused
-      });
-      const lastRenderHadSubscription = useRef3(false);
-      const promiseRef = useRef3(void 0);
-      let {
-        queryCacheKey,
-        requestId
-      } = promiseRef.current || {};
-      let currentRenderHasSubscription = false;
-      if (queryCacheKey && requestId) {
-        currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
-      }
-      const subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;
-      usePossiblyImmediateEffect(() => {
-        lastRenderHadSubscription.current = currentRenderHasSubscription;
-      });
-      usePossiblyImmediateEffect(() => {
-        if (subscriptionRemoved) {
-          promiseRef.current = void 0;
-        }
-      }, [subscriptionRemoved]);
-      usePossiblyImmediateEffect(() => {
-        const lastPromise = promiseRef.current;
-        if (typeof process !== "undefined" && process.env.NODE_ENV === "removeMeOnCompilation") {
-          console.log(subscriptionRemoved);
-        }
-        if (stableArg === skipToken) {
-          lastPromise?.unsubscribe();
-          promiseRef.current = void 0;
-          return;
-        }
-        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
-        if (!lastPromise || lastPromise.arg !== stableArg) {
-          lastPromise?.unsubscribe();
-          const promise = dispatch(initiate(stableArg, {
-            subscriptionOptions: stableSubscriptionOptions,
-            forceRefetch: refetchOnMountOrArgChange
-          }));
-          promiseRef.current = promise;
-        } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
-          lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
-        }
-      }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved]);
-      useEffect3(() => {
-        return () => {
-          promiseRef.current?.unsubscribe();
-          promiseRef.current = void 0;
-        };
-      }, []);
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector3((state) => querySelector(state, lastValue.current), shallowEqual2);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return useQueryState;
+  }
+  function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
+    useEffect3(() => {
+      return () => {
+        promiseRef.current?.unsubscribe?.();
+        promiseRef.current = void 0;
+      };
+    }, [promiseRef]);
+  }
+  function refetchOrErrorIfUnmounted(promiseRef) {
+    if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
+    return promiseRef.current.refetch();
+  }
+  function buildQueryHooks(endpointName) {
+    const useQuerySubscription = (arg, options = {}) => {
+      const [promiseRef] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
       return useMemo2(() => ({
         /**
          * A method to manually refetch data for the query
          */
-        refetch: () => {
-          if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
-          return promiseRef.current?.refetch();
-        }
-      }), []);
+        refetch: () => refetchOrErrorIfUnmounted(promiseRef)
+      }), [promiseRef]);
     };
     const useLazyQuerySubscription = ({
       refetchOnReconnect,
@@ -32266,7 +32759,7 @@ function buildHooks({
     } = {}) => {
       const {
         initiate
-      } = api.endpoints[name];
+      } = api.endpoints[endpointName];
       const dispatch = useDispatch3();
       const [arg, setArg] = useState(UNINITIALIZED_VALUE);
       const promiseRef = useRef3(void 0);
@@ -32298,6 +32791,13 @@ function buildHooks({
         });
         return promise;
       }, [dispatch, initiate]);
+      const reset = useCallback(() => {
+        if (promiseRef.current?.queryCacheKey) {
+          dispatch(api.internalActions.removeQueryResult({
+            queryCacheKey: promiseRef.current?.queryCacheKey
+          }));
+        }
+      }, [dispatch]);
       useEffect3(() => {
         return () => {
           promiseRef?.current?.unsubscribe();
@@ -32308,41 +32808,19 @@ function buildHooks({
           trigger(arg, true);
         }
       }, [arg, trigger]);
-      return useMemo2(() => [trigger, arg], [trigger, arg]);
-    };
-    const useQueryState = (arg, {
-      skip = false,
-      selectFromResult
-    } = {}) => {
-      const {
-        select
-      } = api.endpoints[name];
-      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);
-      const lastValue = useRef3(void 0);
-      const selectDefaultResult = useMemo2(() => createSelector2([select(stableArg), (_2, lastResult) => lastResult, (_2) => stableArg], queryStatePreSelector, {
-        memoizeOptions: {
-          resultEqualityCheck: shallowEqual2
-        }
-      }), [select, stableArg]);
-      const querySelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {
-        devModeChecks: {
-          identityFunctionCheck: "never"
-        }
-      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
-      const currentState = useSelector3((state) => querySelector(state, lastValue.current), shallowEqual2);
-      const store = useStore();
-      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
-      useIsomorphicLayoutEffect(() => {
-        lastValue.current = newLastValue;
-      }, [newLastValue]);
-      return currentState;
+      return useMemo2(() => [trigger, arg, {
+        reset
+      }], [trigger, arg, reset]);
     };
+    const useQueryState = buildUseQueryState(endpointName, queryStatePreSelector);
     return {
       useQueryState,
       useQuerySubscription,
       useLazyQuerySubscription,
       useLazyQuery(options) {
-        const [trigger, arg] = useLazyQuerySubscription(options);
+        const [trigger, arg, {
+          reset
+        }] = useLazyQuerySubscription(options);
         const queryStateResults = useQueryState(arg, {
           ...options,
           skip: arg === UNINITIALIZED_VALUE
@@ -32350,7 +32828,10 @@ function buildHooks({
         const info = useMemo2(() => ({
           lastArg: arg
         }), [arg]);
-        return useMemo2(() => [trigger, queryStateResults, info], [trigger, queryStateResults, info]);
+        return useMemo2(() => [trigger, {
+          ...queryStateResults,
+          reset
+        }, info], [trigger, queryStateResults, reset, info]);
       },
       useQuery(arg, options) {
         const querySubscriptionResults = useQuerySubscription(arg, options);
@@ -32358,22 +32839,8 @@ function buildHooks({
           selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
           ...options
         });
-        const {
-          data,
-          status,
-          isLoading,
-          isSuccess,
-          isError: isError2,
-          error
-        } = queryStateResults;
-        useDebugValue({
-          data,
-          status,
-          isLoading,
-          isSuccess,
-          isError: isError2,
-          error
-        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS);
+        useDebugValue(debugValue);
         return useMemo2(() => ({
           ...queryStateResults,
           ...querySubscriptionResults
@@ -32381,6 +32848,80 @@ function buildHooks({
       }
     };
   }
+  function buildInfiniteQueryHooks(endpointName) {
+    const useInfiniteQuerySubscription = (arg, options = {}) => {
+      const [promiseRef, dispatch, initiate, stableSubscriptionOptions] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = useCallback(function(arg2, direction) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            direction
+          }));
+        });
+        return promise;
+      }, [promiseRef, dispatch, initiate]);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      const stableArg = useStableQueryArgs(
+        options.skip ? skipToken : arg,
+        // Even if the user provided a per-endpoint `serializeQueryArgs` with
+        // a consistent return value, _here_ we want to use the default behavior
+        // so we can tell if _anything_ actually changed. Otherwise, we can end up
+        // with a case where the query args did change but the serialization doesn't,
+        // and then we never try to initiate a refetch.
+        defaultSerializeQueryArgs,
+        context.endpointDefinitions[endpointName],
+        endpointName
+      );
+      const refetch = useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      return useMemo2(() => {
+        const fetchNextPage = () => {
+          return trigger(stableArg, "forward");
+        };
+        const fetchPreviousPage = () => {
+          return trigger(stableArg, "backward");
+        };
+        return {
+          trigger,
+          /**
+           * A method to manually refetch data for the query
+           */
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        };
+      }, [refetch, trigger, stableArg]);
+    };
+    const useInfiniteQueryState = buildUseQueryState(endpointName, infiniteQueryStatePreSelector);
+    return {
+      useInfiniteQueryState,
+      useInfiniteQuerySubscription,
+      useInfiniteQuery(arg, options) {
+        const {
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        } = useInfiniteQuerySubscription(arg, options);
+        const queryStateResults = useInfiniteQueryState(arg, {
+          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS, "hasNextPage", "hasPreviousPage");
+        useDebugValue(debugValue);
+        return useMemo2(() => ({
+          ...queryStateResults,
+          fetchNextPage,
+          fetchPreviousPage,
+          refetch
+        }), [queryStateResults, fetchNextPage, fetchPreviousPage, refetch]);
+      }
+    };
+  }
   function buildMutationHook(name) {
     return ({
       selectFromResult,
@@ -32427,24 +32968,8 @@ function buildHooks({
           }
         });
       }, [dispatch, fixedCacheKey, promise, requestId]);
-      const {
-        endpointName,
-        data,
-        status,
-        isLoading,
-        isSuccess,
-        isError: isError2,
-        error
-      } = currentState;
-      useDebugValue({
-        endpointName,
-        data,
-        status,
-        isLoading,
-        isSuccess,
-        isError: isError2,
-        error
-      });
+      const debugValue = pick(currentState, ...COMMON_HOOK_DEBUG_FIELDS, "endpointName");
+      useDebugValue(debugValue);
       const finalState = useMemo2(() => ({
         ...currentState,
         originalArgs,
@@ -32493,6 +33018,7 @@ Hook ${hookName} was either not provided or not a function.`);
       const anyApi = api;
       const {
         buildQueryHooks,
+        buildInfiniteQueryHooks,
         buildMutationHook,
         usePrefetch
       } = buildHooks({
@@ -32531,12 +33057,25 @@ Hook ${hookName} was either not provided or not a function.`);
             });
             api[`use${capitalize(endpointName)}Query`] = useQuery;
             api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
-          } else if (isMutationDefinition2(definition)) {
+          }
+          if (isMutationDefinition2(definition)) {
             const useMutation = buildMutationHook(endpointName);
             safeAssign2(anyApi.endpoints[endpointName], {
               useMutation
             });
             api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          } else if (isInfiniteQueryDefinition2(definition)) {
+            const {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            } = buildInfiniteQueryHooks(endpointName);
+            safeAssign2(anyApi.endpoints[endpointName], {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            });
+            api[`use${capitalize(endpointName)}InfiniteQuery`] = useInfiniteQuery;
           }
         }
       };
@@ -32728,14 +33267,15 @@ var orchestratorApi = createApi2({
       (query) => query.apiName === apiName
     );
     switch (baseQueryType) {
-      case "fetch" /* fetch */:
+      case "fetch" /* fetch */: {
         const fetchFn = fetchBaseQuery({
           baseUrl: customApi ? customApi.apiBaseUrl : orchestratorApiBaseUrl,
           prepareHeaders,
           responseHandler: (response) => catchErrorResponse(response, authActive)
         });
         return fetchFn(args, api, {});
-      default:
+      }
+      default: {
         const graphqlFn = wfoGraphqlRequestBaseQuery(
           {
             url: customApi ? customApi.apiBaseUrl : graphqlEndpointCore,
@@ -32747,6 +33287,7 @@ var orchestratorApi = createApi2({
           authActive
         );
         return graphqlFn(args, api, {});
+      }
     }
   },
   endpoints: () => ({}),
@@ -36686,7 +37227,7 @@ function getTableConfig(hiddenColumns = [], selectedPageSize = DEFAULT_PAGE_SIZE
 }
 var getDefaultTableConfig = (storageKey) => {
   switch (storageKey) {
-    case METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY:
+    case METADATA_PRODUCT_BLOCKS_TABLE_LOCAL_STORAGE_KEY: {
       const productBlockColumns = [
         "productBlockId",
         "status",
@@ -36694,12 +37235,14 @@ var getDefaultTableConfig = (storageKey) => {
         "createdAt"
       ];
       return getTableConfig(productBlockColumns);
-    case METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case METADATA_RESOURCE_TYPES_TABLE_LOCAL_STORAGE_KEY: {
       const resourceTypeColumns = [
         "resourceTypeId"
       ];
       return getTableConfig(resourceTypeColumns);
-    case METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case METADATA_PRODUCT_TABLE_LOCAL_STORAGE_KEY: {
       const productColumns = [
         "productId",
         "productType",
@@ -36707,19 +37250,22 @@ var getDefaultTableConfig = (storageKey) => {
         "createdAt"
       ];
       return getTableConfig(productColumns);
-    case METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case METADATA_WORKFLOWS_TABLE_LOCAL_STORAGE_KEY: {
       const workflowColumns = [
         "workflowId",
         "createdAt"
       ];
       return getTableConfig(workflowColumns);
-    case METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case METADATA_TASKS_TABLE_LOCAL_STORAGE_KEY: {
       const taskColumns = [
         "workflowId",
         "createdAt"
       ];
       return getTableConfig(taskColumns);
-    case ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case ACTIVE_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
       const activeProcessColumns = [
         "productName",
         "customer",
@@ -36728,7 +37274,8 @@ var getDefaultTableConfig = (storageKey) => {
         "startedAt"
       ];
       return getTableConfig(activeProcessColumns);
-    case COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case COMPLETED_PROCESSES_LIST_TABLE_LOCAL_STORAGE_KEY: {
       const completedProcessColumns = [
         "lastStep",
         "productName",
@@ -36738,7 +37285,8 @@ var getDefaultTableConfig = (storageKey) => {
         "startedAt"
       ];
       return getTableConfig(completedProcessColumns);
-    case ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case ACTIVE_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
       const activeTasksColumns = [
         "assignee",
         "workflowTarget",
@@ -36747,7 +37295,8 @@ var getDefaultTableConfig = (storageKey) => {
         "processId"
       ];
       return getTableConfig(activeTasksColumns);
-    case COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case COMPLETED_TASKS_LIST_TABLE_LOCAL_STORAGE_KEY: {
       const completedTasksColumns = [
         "assignee",
         "workflowTarget",
@@ -36756,13 +37305,15 @@ var getDefaultTableConfig = (storageKey) => {
         "processId"
       ];
       return getTableConfig(completedTasksColumns);
-    case SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY:
+    }
+    case SUBSCRIPTIONS_TABLE_LOCAL_STORAGE_KEY: {
       const subscriptionColumns = [
         "productName",
         "customerFullname",
         "metadata"
       ];
       return getTableConfig(subscriptionColumns);
+    }
     default:
       return getTableConfig();
   }
@@ -36772,16 +37323,19 @@ var getDefaultTableConfig = (storageKey) => {
 import process2 from "process";
 function getEnvironmentVariables(envVars) {
   const missingEnvironmentVariables = [];
-  const environmentVariablesWithValues = envVars.reduce((acc, currentKey) => {
-    const value = process2.env[currentKey.toString()];
-    if (value === void 0) {
-      missingEnvironmentVariables.push(currentKey.toString());
-    }
-    return {
-      ...acc,
-      [currentKey]: value || ""
-    };
-  }, {});
+  const environmentVariablesWithValues = envVars.reduce(
+    (acc, currentKey) => {
+      const value = process2.env[currentKey.toString()];
+      if (value === void 0) {
+        missingEnvironmentVariables.push(currentKey.toString());
+      }
+      return {
+        ...acc,
+        [currentKey]: value || ""
+      };
+    },
+    {}
+  );
   if (missingEnvironmentVariables.length > 0) {
     console.warn(
       `Warning: Missing required environment variables: ${missingEnvironmentVariables.join(
@@ -36948,7 +37502,7 @@ var getUrlWithQueryParams = (url, params) => {
 
 // src/components/WfoPageTemplate/WfoPageHeader/WfoHamburgerMenu.tsx
 import { jsx as jsx57 } from "@emotion/react/jsx-runtime";
-var WfoHamburgerMenu = ({}) => {
+var WfoHamburgerMenu = () => {
   const t = useTranslations4("hamburgerMenu");
   const [isPopoverOpen, setPopoverIsOpen] = useState7(false);
   const { theme, isDarkThemeActive } = useOrchestratorTheme();
@@ -42761,8 +43315,8 @@ var WfoCustomerDescriptionsField = ({ customerDescriptions, subscriptionCustomer
     customerDescriptionsCustomerNameStyle,
     customerDescriptionsFormStyle
   } = useWithOrchestratorTheme(getSubscriptionDetailStyles);
-  const [updateCustomerDescription, {}] = useUpdateCustomerDescriptionMutation();
-  const [setCustomerDescription, {}] = useSetCustomerDescriptionMutation();
+  const [updateCustomerDescription] = useUpdateCustomerDescriptionMutation();
+  const [setCustomerDescription] = useSetCustomerDescriptionMutation();
   const customerIds = customerDescriptions.map(
     (customerDescription) => customerDescription.customerId
   );
@@ -42916,7 +43470,7 @@ var TableSettingsModal = ({
           /* @__PURE__ */ jsx134(
             EuiFormRow2,
             {
-              display: "columnCompressedSwitch",
+              display: "columnCompressed",
               label: name,
               css: formRowStyle,
               children: /* @__PURE__ */ jsx134(
@@ -44589,7 +45143,7 @@ function UnconnectedSelectField({
     if (selectedValue && selectedValue.value !== "undefined") {
       onChange(selectedValue.value);
     }
-  }, []);
+  }, [onChange, selectedValue]);
   if (fieldType === Array) {
     return /* @__PURE__ */ jsx157(ListField, { name, children: /* @__PURE__ */ jsx157(ListItemField, { name: "$", children: /* @__PURE__ */ jsx157(
       ListSelectField,
@@ -46218,7 +46772,7 @@ function Vlan({
     } else if (!disabled && (!subscriptionId && value !== "" || subscriptionId && portIsTagged && value === "0")) {
       onChange("");
     }
-  }, [onChange, subscriptionId, isFetched, portIsTagged]);
+  }, [onChange, subscriptionId, isFetched, portIsTagged, value, disabled]);
   const [usedVlansInIms, setUsedVlansInIms] = useState31([]);
   const [missingInIms, setMissingInIms] = useState31(false);
   const {
@@ -49227,7 +49781,7 @@ var WfoProcessDetail = ({
     question: t(
       processIsTask ? "retryTaskQuestion" : "retryWorkflowQuestion",
       {
-        workflowName: processDetail?.workflowName
+        workflowName: processDetail?.workflowName || ""
       }
     ),
     onConfirm: () => {
@@ -49240,7 +49794,7 @@ var WfoProcessDetail = ({
     question: t(
       processIsTask ? "abortTaskQuestion" : "abortWorkflowQuestion",
       {
-        workflowName: processDetail?.workflowName
+        workflowName: processDetail?.workflowName || ""
       }
     ),
     onConfirm: () => {
@@ -49252,7 +49806,7 @@ var WfoProcessDetail = ({
   });
   const deleteAction = () => showConfirmDialog({
     question: t("deleteQuestion", {
-      workflowName: processDetail?.workflowName
+      workflowName: processDetail?.workflowName || ""
     }),
     onConfirm: () => {
       if (processDetail?.processId) {
@@ -50022,7 +50576,10 @@ var WfoStep = React65.forwardRef(
       getStepToggleExpandStyle
     } = useWithOrchestratorTheme(getWorkflowStepsStyles);
     const t = useTranslations61("processes.steps");
-    const hasHtmlMail = step.stateDelta?.hasOwnProperty("confirmation_mail");
+    const hasHtmlMail = Object.prototype.hasOwnProperty.call(
+      step?.stateDelta || {},
+      "confirmation_mail"
+    );
     const stepContent = step.stateDelta ? getStepContent(step.stateDelta, showHiddenKeys) : {};
     const hasStepContent = hasHtmlMail || Object.keys(stepContent).length > 0;
     const displayMailConfirmation = (value) => {
@@ -50413,9 +50970,11 @@ var WfoProcessSubscriptionDelta = ({
   processId
 }) => {
   const { data, isFetching } = useGetRawProcessDetailQuery({ processId });
-  const subscriptionKey = data?.current_state?.subscription?.subscription_id ?? "";
+  const subscriptionId = data?.current_state?.subscription?.subscription_id ?? "";
   const newText = data?.current_state?.subscription ?? null;
-  const oldText = data?.current_state?.__old_subscriptions__ && subscriptionKey in data?.current_state?.__old_subscriptions__ ? data?.current_state?.__old_subscriptions__[subscriptionKey] : null;
+  const oldSubscriptions = data?.current_state?.__old_subscriptions__ || {};
+  const oldSubscription = subscriptionId in oldSubscriptions;
+  const oldText = oldSubscription || null;
   return isFetching ? /* @__PURE__ */ jsx210(WfoLoading, {}) : /* @__PURE__ */ jsx210(
     WfoDiff_default,
     {