react-redux-cache 0.22.0 → 0.22.2

package/dist/types/createActions.d.ts

@@ -7,18 +7,18 @@ export type Actions<
   QP = unknown,
   QR = unknown,
   MP = unknown,
-  MR = unknown
+  MR = unknown,
 > = ReturnType<typeof createActions<N, T, QP, QR, MP, MR>>
 
 export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(
-  name: N
+  name: N,
 ) => {
   updateQueryStateAndEntities: {
     <K extends keyof (QP | QR)>(
       queryKey: K,
       queryCacheKey: Key,
       state?: Partial<QueryState<T, QP[K], QR[K]>>,
-      entityChanges?: EntityChanges<T>
+      entityChanges?: EntityChanges<T>,
     ): {
       type: `@rrc/${N}/updateQueryStateAndEntities`
       queryKey: K
@@ -32,7 +32,7 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     <K extends keyof (MP | MR)>(
       mutationKey: K,
       state?: Partial<MutationState<T, MP[K], MR[K]>>,
-      entityChanges?: EntityChanges<T>
+      entityChanges?: EntityChanges<T>,
     ): {
       type: `@rrc/${N}/updateMutationStateAndEntities`
       mutationKey: K
@@ -57,7 +57,7 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
         cacheKey?: Key
         /** Unix timestamp at which query expires. Is set to the query state. @Default Date.now() */
         expiresAt?: number
-      }[]
+      }[],
     ): {
       type: `@rrc/${N}/invalidateQuery`
       queries: {
@@ -78,7 +78,7 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
         query: K
         /** Query cache key */
         cacheKey?: Key
-      }[]
+      }[],
     ): {
       type: `@rrc/${N}/clearQueryState`
       queries: {
@@ -91,7 +91,9 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     type: `@rrc/${N}/clearQueryState`
   }
   clearMutationState: {
-    <K extends keyof (MP | MR)>(mutationKeys: K[]): {
+    <K extends keyof (MP | MR)>(
+      mutationKeys: K[],
+    ): {
       type: `@rrc/${N}/clearMutationState`
       mutationKeys: K[]
     }

package/dist/types/createCache.d.ts

@@ -38,7 +38,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       'options' | 'queries' | 'mutations' | 'cacheStateSelector' | 'storeHooks'
     > & {
       globals?: OptionalPartial<Cache<N, T, QP, QR, MP, MR>['globals'], 'queries'>
-    }
+    },
   ) => {
     /** Keeps all options, passed while creating the cache. */
     cache: Cache<N, T, QP, QR, MP, MR>
@@ -85,7 +85,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         | {
             type: `@rrc/${N}/clearCache`
             stateToKeep: Partial<CacheState<T, QP, QR, MP, MR>> | undefined
-          }
+          },
     ) => CacheState<T, QP, QR, MP, MR>
     actions: {
       /** Updates query state, and optionally merges entity changes in a single action. */
@@ -94,7 +94,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
           queryKey: K,
           queryCacheKey: Key,
           state?: Partial<QueryState<T, QP[K], QR[K]>> | undefined,
-          entityChanges?: EntityChanges<T> | undefined
+          entityChanges?: EntityChanges<T> | undefined,
         ): {
           type: `@rrc/${N}/updateQueryStateAndEntities`
           queryKey: K
@@ -109,7 +109,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         <K extends keyof MP & keyof MR>(
           mutationKey: K,
           state?: Partial<MutationState<T, MP[K], MR[K]>> | undefined,
-          entityChanges?: EntityChanges<T> | undefined
+          entityChanges?: EntityChanges<T> | undefined,
         ): {
           type: `@rrc/${N}/updateMutationStateAndEntities`
           mutationKey: K
@@ -133,7 +133,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             query: K
             cacheKey?: Key
             expiresAt?: number
-          }[]
+          }[],
         ): {
           type: `@rrc/${N}/invalidateQuery`
           queries: {
@@ -151,7 +151,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
           queries: {
             query: K
             cacheKey?: Key
-          }[]
+          }[],
         ): {
           type: `@rrc/${N}/clearQueryState`
           queries: {
@@ -163,7 +163,9 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       }
       /** Clears states for provided mutation keys. */
       clearMutationState: {
-        <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
+        <K extends keyof MP & keyof MR>(
+          mutationKeys: K[],
+        ): {
           type: `@rrc/${N}/clearMutationState`
           mutationKeys: K[]
         }
@@ -185,7 +187,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       selectQueryState: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => QueryState<
         T,
         QK extends keyof QP & keyof QR ? QP[QK] : never,
@@ -195,36 +197,36 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       selectQueryResult: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined
       /** Selects query loading state. */
       selectQueryLoading: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => false | Promise<NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>
       /** Selects query latest error. */
       selectQueryError: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => Error | undefined
       /** Selects query latest params. */
       selectQueryParams: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined
       /** Selects query latest expiresAt. */
       selectQueryExpiresAt: <QK extends keyof QP | keyof QR>(
         state: unknown,
         query: QK,
-        cacheKey: Key
+        cacheKey: Key,
       ) => number | undefined
       /** Selects mutation state. */
       selectMutationState: <MK extends keyof MP | keyof MR>(
         state: unknown,
-        mutation: MK
+        mutation: MK,
       ) => MutationState<
         T,
         MK extends keyof MP & keyof MR ? MP[MK] : never,
@@ -233,32 +235,32 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
       /** Selects mutation latest result. */
       selectMutationResult: <MK extends keyof MP | keyof MR>(
         state: unknown,
-        mutation: MK
+        mutation: MK,
       ) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined
       /** Selects mutation loading state. */
       selectMutationLoading: <MK extends keyof MP | keyof MR>(
         state: unknown,
-        mutation: MK
+        mutation: MK,
       ) => false | Promise<NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>
       /** Selects mutation latest error. */
       selectMutationError: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => Error | undefined
       /** Selects mutation latest params. */
       selectMutationParams: <MK extends keyof MP | keyof MR>(
         state: unknown,
-        mutation: MK
+        mutation: MK,
       ) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined
       /** Selects entity by id and typename. */
       selectEntityById: <TN extends keyof T>(
         state: unknown,
         id: Key | null | undefined,
-        typename: TN
+        typename: TN,
       ) => T[TN] | undefined
       /** Selects all entities. */
       selectEntities: (state: unknown) => EntitiesMap<T> & import('./types').Mutable
       /** Selects all entities of provided typename. */
       selectEntitiesByTypename: <TN extends keyof T>(
         state: unknown,
-        typename: TN
+        typename: TN,
       ) => (EntitiesMap<T> & import('./types').Mutable)[TN]
     }
     hooks: {
@@ -270,18 +272,18 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
          * @param skipFetch Fetch is cancelled and current cached result is returned.
          */
         query: <QK extends keyof (QP & QR)>(
-          options: QueryOptions<N, T, QP, QR, QK, MP, MR>
+          options: QueryOptions<N, T, QP, QR, QK, MP, MR>,
         ) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>
         /**
          * Performs a mutation, aborting previous one with the same mutation key. Returns result only if finished succesfully.
          */
         mutate: <MK extends keyof (MP & MR)>(
-          options: MutateOptions<N, T, QP, QR, MP, MR, MK>
+          options: MutateOptions<N, T, QP, QR, MP, MR, MK>,
         ) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>
       }
       /** Fetches query when params change and subscribes to query state changes (subscription depends on `selectorComparer`). */
       useQuery: <QK extends keyof (QP & QR)>(
-        options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[3]
+        options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[3],
       ) => readonly [
         Omit<
           QueryState<
@@ -294,7 +296,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         (
           options?:
             | Partial<Pick<QueryOptions<N, T, QP, QR, QK, MP, MR>, 'params' | 'onlyIfExpired'>>
-            | undefined
+            | undefined,
         ) => Promise<
           QueryResult<
             QK extends infer T_1
@@ -305,14 +307,14 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 : never
               : never
           >
-        >
+        >,
       ]
       /** Subscribes to provided mutation state and provides mutate function. */
       useMutation: <MK extends keyof (MP & MR)>(
-        options: Parameters<typeof useMutation<N, T, QP, QR, MP, MR, MK>>[3]
+        options: Parameters<typeof useMutation<N, T, QP, QR, MP, MR, MK>>[3],
       ) => readonly [
         (
-          params: MK extends keyof MP & keyof MR ? MP[MK] : never
+          params: MK extends keyof MP & keyof MR ? MP[MK] : never,
         ) => Promise<
           MutationResult<
             MK extends infer T_1
@@ -329,7 +331,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
           MK extends keyof MP & keyof MR ? MP[MK] : never,
           MK extends keyof MP & keyof MR ? MP[MK] : never
         >,
-        () => boolean
+        () => boolean,
       ]
       /** useSelector + selectEntityById. */
       useSelectEntityById: <TN extends keyof T>(id: Key | null | undefined, typename: TN) => T[TN] | undefined
@@ -338,7 +340,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
        * @warning Subscribing to collections should be avoided.
        * */
       useEntitiesByTypename: <TN extends keyof T>(
-        typename: TN
+        typename: TN,
       ) => (EntitiesMap<T> & import('./types').Mutable)[TN]
     }
     utils: {
@@ -350,13 +352,13 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
          * @param skipFetch Fetch is cancelled and current cached result is returned.
          */
         query: <QK extends keyof (QP & QR)>(
-          options: QueryOptions<N, T, QP, QR, QK, MP, MR>
+          options: QueryOptions<N, T, QP, QR, QK, MP, MR>,
         ) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>
         /**
          * Performs a mutation, aborting previous one with the same mutation key. Returns result only if finished succesfully.
          */
         mutate: <MK extends keyof (MP & MR)>(
-          options: MutateOptions<N, T, QP, QR, MP, MR, MK>
+          options: MutateOptions<N, T, QP, QR, MP, MR, MK>,
         ) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>
       }
       /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
@@ -369,7 +371,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
        */
       applyEntityChanges: (
         entities: Parameters<typeof applyEntityChanges<T>>[0],
-        changes: Parameters<typeof applyEntityChanges<T>>[1]
+        changes: Parameters<typeof applyEntityChanges<T>>[1],
       ) => EntitiesMap<T> | undefined
     }
   }
@@ -400,7 +402,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       'queries' | 'mutations' | 'options' | 'storeHooks' | 'cacheStateSelector'
     > & {
       globals?: OptionalPartial<Globals<N, Typenames, QP, QR, MP, MR>, 'queries'> | undefined
-    }
+    },
 ) => {
   /** Keeps all options, passed while creating the cache. */
   cache: Cache<N, Typenames, QP, QR, MP, MR>
@@ -449,7 +451,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       | {
           type: `@rrc/${N}/clearCache`
           stateToKeep: Partial<CacheState<Typenames, QP, QR, MP, MR>> | undefined
-        }
+        },
   ) => CacheState<Typenames, QP, QR, MP, MR>
   actions: {
     /** Updates query state, and optionally merges entity changes in a single action. */
@@ -458,7 +460,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
         queryKey: K,
         queryCacheKey: Key,
         state?: Partial<QueryState<Typenames, QP[K], QR[K]>> | undefined,
-        entityChanges?: EntityChanges<Typenames> | undefined
+        entityChanges?: EntityChanges<Typenames> | undefined,
       ): {
         type: `@rrc/${N}/updateQueryStateAndEntities`
         queryKey: K
@@ -473,7 +475,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       <K extends keyof MP & keyof MR>(
         mutationKey: K,
         state?: Partial<MutationState<Typenames, MP[K], MR[K]>> | undefined,
-        entityChanges?: EntityChanges<Typenames> | undefined
+        entityChanges?: EntityChanges<Typenames> | undefined,
       ): {
         type: `@rrc/${N}/updateMutationStateAndEntities`
         mutationKey: K
@@ -497,7 +499,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
           query: K
           cacheKey?: Key
           expiresAt?: number
-        }[]
+        }[],
       ): {
         type: `@rrc/${N}/invalidateQuery`
         queries: {
@@ -515,7 +517,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
         queries: {
           query: K
           cacheKey?: Key
-        }[]
+        }[],
       ): {
         type: `@rrc/${N}/clearQueryState`
         queries: {
@@ -527,7 +529,9 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     }
     /** Clears states for provided mutation keys. */
     clearMutationState: {
-      <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
+      <K extends keyof MP & keyof MR>(
+        mutationKeys: K[],
+      ): {
         type: `@rrc/${N}/clearMutationState`
         mutationKeys: K[]
       }
@@ -549,7 +553,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     selectQueryState: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) => QueryState<
       Typenames,
       QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never,
@@ -559,13 +563,13 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     selectQueryResult: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) => (QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never) | undefined
     /** Selects query loading state. */
     selectQueryLoading: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) =>
       | false
       | Promise<NormalizedQueryResponse<Typenames, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>
@@ -573,24 +577,24 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     selectQueryError: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) => Error | undefined
     /** Selects query latest params. */
     selectQueryParams: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) => (QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never) | undefined
     /** Selects query latest expiresAt. */
     selectQueryExpiresAt: <QK_1 extends keyof QP | keyof QR>(
       state: unknown,
       query: QK_1,
-      cacheKey: Key
+      cacheKey: Key,
     ) => number | undefined
     /** Selects mutation state. */
     selectMutationState: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
-      mutation: MK_1
+      mutation: MK_1,
     ) => MutationState<
       Typenames,
       MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never,
@@ -599,37 +603,37 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
     /** Selects mutation latest result. */
     selectMutationResult: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
-      mutation: MK_1
+      mutation: MK_1,
     ) => (MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never) | undefined
     /** Selects mutation loading state. */
     selectMutationLoading: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
-      mutation: MK_1
+      mutation: MK_1,
     ) =>
       | false
       | Promise<NormalizedQueryResponse<Typenames, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     /** Selects mutation latest error. */
     selectMutationError: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
-      mutation: MK_1
+      mutation: MK_1,
     ) => Error | undefined
     /** Selects mutation latest params. */
     selectMutationParams: <MK_1 extends keyof MP | keyof MR>(
       state: unknown,
-      mutation: MK_1
+      mutation: MK_1,
     ) => (MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) | undefined
     /** Selects entity by id and typename. */
     selectEntityById: <TN extends string>(
       state: unknown,
       id: Key | null | undefined,
-      typename: TN
+      typename: TN,
     ) => object | undefined
     /** Selects all entities. */
     selectEntities: (state: unknown) => EntitiesMap<Typenames> & import('./types').Mutable
     /** Selects all entities of provided typename. */
     selectEntitiesByTypename: <TN extends string>(
       state: unknown,
-      typename: TN
+      typename: TN,
     ) => (EntitiesMap<Typenames> & import('./types').Mutable)[TN]
   }
   hooks: {
@@ -641,18 +645,18 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
        * @param skipFetch Fetch is cancelled and current cached result is returned.
        */
       query: <QK_1 extends keyof QP | keyof QR>(
-        options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>
+        options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>,
       ) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>
       /**
        * Performs a mutation, aborting previous one with the same mutation key. Returns result only if finished succesfully.
        */
       mutate: <MK_1 extends keyof MP | keyof MR>(
-        options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>
+        options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>,
       ) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     }
     /** Fetches query when params change and subscribes to query state changes (subscription depends on `selectorComparer`). */
     useQuery: <QK_1 extends keyof QP | keyof QR>(
-      options: UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>
+      options: UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>,
     ) => readonly [
       Omit<
         QueryState<
@@ -665,7 +669,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
       (
         options?:
           | Partial<Pick<QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>, 'params' | 'onlyIfExpired'>>
-          | undefined
+          | undefined,
       ) => Promise<
         QueryResult<
           QK_1 extends infer T
@@ -676,14 +680,14 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
               : never
             : never
         >
-      >
+      >,
     ]
     /** Subscribes to provided mutation state and provides mutate function. */
     useMutation: <MK_1 extends keyof MP | keyof MR>(
-      options: Omit<MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>, 'params'>
+      options: Omit<MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>, 'params'>,
     ) => readonly [
       (
-        params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never
+        params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never,
       ) => Promise<
         MutationResult<
           MK_1 extends infer T
@@ -700,7 +704,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
         MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never,
         MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never
       >,
-      () => boolean
+      () => boolean,
     ]
     /** useSelector + selectEntityById. */
     useSelectEntityById: <TN extends string>(id: Key | null | undefined, typename: TN) => object | undefined
@@ -709,7 +713,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
      * @warning Subscribing to collections should be avoided.
      * */
     useEntitiesByTypename: <TN extends string>(
-      typename: TN
+      typename: TN,
     ) => (EntitiesMap<Typenames> & import('./types').Mutable)[TN]
   }
   utils: {
@@ -721,13 +725,13 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
        * @param skipFetch Fetch is cancelled and current cached result is returned.
        */
       query: <QK_1 extends keyof QP | keyof QR>(
-        options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>
+        options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>,
       ) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>
       /**
        * Performs a mutation, aborting previous one with the same mutation key. Returns result only if finished succesfully.
        */
       mutate: <MK_1 extends keyof MP | keyof MR>(
-        options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>
+        options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>,
       ) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>
     }
     /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
@@ -740,7 +744,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(
      */
     applyEntityChanges: (
       entities: EntitiesMap<Typenames> & import('./types').Mutable,
-      changes: EntityChanges<Typenames>
+      changes: EntityChanges<Typenames>,
     ) => EntitiesMap<Typenames> | undefined
   }
 }

package/dist/types/createReducer.d.ts

@@ -4,8 +4,8 @@ import type {CacheOptions, CacheState, Typenames} from './types'
 export declare const createReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(
   actions: Actions<N, T, QP, QR, MP, MR>,
   queryKeys: (keyof (QP | QR))[],
-  cacheOptions: CacheOptions
+  cacheOptions: CacheOptions,
 ) => (
   state: CacheState<T, QP, QR, MP, MR> | undefined,
-  action: ReturnType<(typeof actions)[keyof typeof actions]>
+  action: ReturnType<(typeof actions)[keyof typeof actions]>,
 ) => CacheState<T, QP, QR, MP, MR>

package/dist/types/createSelectors.d.ts

@@ -6,52 +6,52 @@ export type Selectors<
   QP = unknown,
   QR = unknown,
   MP = unknown,
-  MR = unknown
+  MR = unknown,
 > = ReturnType<typeof createSelectors<N, T, QP, QR, MP, MR>>
 
 export declare const createSelectors: <N extends string, T extends Typenames, QP, QR, MP, MR>(
-  cache: Cache<N, T, QP, QR, MP, MR>
+  cache: Cache<N, T, QP, QR, MP, MR>,
 ) => {
   selectEntityById: <TN extends keyof T>(
     state: unknown,
     id: Key | null | undefined,
-    typename: TN
+    typename: TN,
   ) => T[TN] | undefined
   selectQueryState: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) => QueryState<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>
   selectQueryResult: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined
   selectQueryLoading: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) =>
     | false
     | Promise<import('./types').NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>
   selectQueryError: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) => Error | undefined
   selectQueryParams: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined
   selectQueryExpiresAt: <QK extends keyof (QP & QR)>(
     state: unknown,
     query: QK,
-    cacheKey: Key
+    cacheKey: Key,
   ) => number | undefined
   selectMutationState: <MK extends keyof (MP & MR)>(
     state: unknown,
-    mutation: MK
+    mutation: MK,
   ) => MutationState<
     T,
     MK extends keyof (MP | MR) ? MP[MK] : never,
@@ -59,22 +59,22 @@ export declare const createSelectors: <N extends string, T extends Typenames, QP
   >
   selectMutationResult: <MK extends keyof (MP & MR)>(
     state: unknown,
-    mutation: MK
+    mutation: MK,
   ) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined
   selectMutationLoading: <MK extends keyof (MP & MR)>(
     state: unknown,
-    mutation: MK
+    mutation: MK,
   ) =>
     | false
     | Promise<import('./types').NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>
   selectMutationError: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => Error | undefined
   selectMutationParams: <MK extends keyof (MP & MR)>(
     state: unknown,
-    mutation: MK
+    mutation: MK,
   ) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined
   selectEntities: (state: unknown) => import('./types').EntitiesMap<T> & import('./types').Mutable
   selectEntitiesByTypename: <TN extends keyof T>(
     state: unknown,
-    typename: TN
+    typename: TN,
   ) => (import('./types').EntitiesMap<T> & import('./types').Mutable)[TN]
 }

package/dist/types/index.d.ts

@@ -1,5 +1,3 @@
 export {createCache, withTypenames} from './createCache'
-
 export * from './types'
-
 export {createStateComparer, defaultGetCacheKey, FetchPolicy, isEmptyObject, noop} from './utilsAndConstants'