diff --git a/packages/solid-query/src/__tests__/useQuery.test-d.tsx b/packages/solid-query/src/__tests__/useQuery.test-d.tsx
index 89c383859f..ec11493862 100644
--- a/packages/solid-query/src/__tests__/useQuery.test-d.tsx
+++ b/packages/solid-query/src/__tests__/useQuery.test-d.tsx
@@ -2,97 +2,99 @@ import { describe, expectTypeOf, it } from 'vitest'
 import { queryOptions, useQuery } from '../index'
 
 describe('useQuery', () => {
-  describe('Config object overload', () => {
-    it('TData should always be defined when initialData is provided as an object', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
-
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
-
-    it('TData should be defined when passed through queryOptions', () => {
-      const options = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
+  describe('initialData', () => {
+    describe('Config object overload', () => {
+      it('TData should always be defined when initialData is provided as an object', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
       })
-      const { data } = useQuery(() => options)
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+      it('TData should be defined when passed through queryOptions', () => {
+        const options = queryOptions({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        })
+        const { data } = useQuery(() => options)
 
-    it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: () => ({ wow: true }),
-      }))
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+      it('TData should always be defined when initialData is provided as a function which ALWAYS returns the data', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: () => ({ wow: true }),
+        }))
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
-    })
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
 
-    it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: () => undefined as { wow: boolean } | undefined,
-      }))
+      it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: () => undefined as { wow: boolean } | undefined,
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
-  })
 
-  describe('Query key overload', () => {
-    it('TData should always be defined when initialData is provided', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
+    describe('Query key overload', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
-  })
 
-  describe('Query key and func', () => {
-    it('TData should always be defined when initialData is provided', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
+    describe('Query key and func', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = useQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = useQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
   })
 })
diff --git a/packages/svelte-query/tests/createQuery.test-d.ts b/packages/svelte-query/tests/createQuery.test-d.ts
index ed44e967c1..2f25052463 100644
--- a/packages/svelte-query/tests/createQuery.test-d.ts
+++ b/packages/svelte-query/tests/createQuery.test-d.ts
@@ -2,87 +2,89 @@ import { describe, expectTypeOf, it } from 'vitest'
 import { createQuery, queryOptions } from '../src/index.js'
 
 describe('createQuery', () => {
-  describe('Config object overload', () => {
-    it('TData should always be defined when initialData is provided as an object', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
-
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
-
-    it('TData should be defined when passed through queryOptions', () => {
-      const options = queryOptions({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
+  describe('initialData', () => {
+    describe('Config object overload', () => {
+      it('TData should always be defined when initialData is provided as an object', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
       })
-      const { data } = createQuery(() => options)
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+      it('TData should be defined when passed through queryOptions', () => {
+        const options = queryOptions({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        })
+        const { data } = createQuery(() => options)
+
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
-    })
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
 
-    it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: () => undefined as { wow: boolean } | undefined,
-      }))
+      it('TData should have undefined in the union when initialData is provided as a function which can return undefined', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: () => undefined as { wow: boolean } | undefined,
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
-  })
 
-  describe('Query key overload', () => {
-    it('TData should always be defined when initialData is provided', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
+    describe('Query key overload', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
-  })
 
-  describe('Query key and func', () => {
-    it('TData should always be defined when initialData is provided', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-        initialData: { wow: true },
-      }))
+    describe('Query key and func', () => {
+      it('TData should always be defined when initialData is provided', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+          initialData: { wow: true },
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
-    })
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean }>()
+      })
 
-    it('TData should have undefined in the union when initialData is NOT provided', () => {
-      const { data } = createQuery(() => ({
-        queryKey: ['key'],
-        queryFn: () => ({ wow: true }),
-      }))
+      it('TData should have undefined in the union when initialData is NOT provided', () => {
+        const { data } = createQuery(() => ({
+          queryKey: ['key'],
+          queryFn: () => ({ wow: true }),
+        }))
 
-      expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+        expectTypeOf(data).toEqualTypeOf<{ wow: boolean } | undefined>()
+      })
     })
   })
 })