@sanity/sdk 2.18.0 → 3.0.0-rc.1

package/src/organizations/organizations.ts

@@ -7,8 +7,8 @@ import {
   type OrganizationOptions,
 } from '../organization/organization'
 import {type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {createFetcherStore} from '../utils/createFetcherStore'
+import {defineFetcher} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
 
 const API_VERSION = 'v2025-02-19'
 
@@ -57,7 +57,7 @@ export interface OrganizationsOptions<
   includeImplicitMemberships?: boolean
 }
 
-function normalizeOrganizationOptions(options?: OrganizationsOptions<boolean, boolean>) {
+function normalizeOrganizationsOptions(options?: OrganizationsOptions<boolean, boolean>) {
   return {
     includeImplicitMemberships: options?.includeImplicitMemberships ?? false,
     includeMembers: options?.includeMembers ?? false,
@@ -71,62 +71,37 @@ export function getOrganizationsCacheKey(
   options?: OrganizationsOptions<boolean, boolean>,
 ): string {
   const {includeMembers, includeFeatures, includeImplicitMemberships} =
-    normalizeOrganizationOptions(options)
+    normalizeOrganizationsOptions(options)
   const membersKey = includeMembers ? ':members' : ''
   const featuresKey = includeFeatures ? ':features' : ''
   const implicitKey = includeImplicitMemberships ? ':implicit' : ''
   return `organizations${membersKey}${featuresKey}${implicitKey}`
 }
 
-const organizations = createFetcherStore({
-  name: 'Organizations',
-  getKey: getOrganizationsCacheKey,
-  fetcher: (instance) => (options?: OrganizationsOptions<boolean, boolean>) => {
-    return getClientState(instance, {
-      apiVersion: API_VERSION,
-      scope: 'global',
-    }).observable.pipe(
-      switchMap((client) => {
-        const normalized = normalizeOrganizationOptions(options)
-        const query = Object.fromEntries(
-          Object.entries(normalized)
-            .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => [key, String(value)]),
-        )
-
-        return client.observable.request({
-          uri: `/organizations`,
-          query,
-          tag: 'organizations.get',
-        })
-      }),
-    )
-  },
-})
-
 /**
- * Public signature for the organization state source. The conditional generics
- * cannot flow through `BoundStoreAction`, so we declare the signature here
- * and assign the (already-correct) runtime function to it.
+ * Fetcher for the current user's organizations (`GET /organizations`), on the
+ * shared fetcher cache.
+ *
+ * @internal
  */
-type GetOrganizationsState = <
-  IncludeMembers extends boolean = false,
-  IncludeFeatures extends boolean = false,
->(
-  instance: SanityInstance,
-  options?: OrganizationsOptions<IncludeMembers, IncludeFeatures>,
-) => StateSource<Organizations<IncludeMembers, IncludeFeatures> | undefined>
-
-type ResolveOrganizations = <
-  IncludeMembers extends boolean = false,
-  IncludeFeatures extends boolean = false,
->(
-  instance: SanityInstance,
-  options?: OrganizationsOptions<IncludeMembers, IncludeFeatures>,
-) => Promise<Organizations<IncludeMembers, IncludeFeatures>>
-
-/** @public */
-export const getOrganizationsState: GetOrganizationsState = organizations.getState
-
-/** @public */
-export const resolveOrganizations: ResolveOrganizations = organizations.resolveState
+export const organizations = defineFetcher<
+  [options?: OrganizationsOptions<boolean, boolean>],
+  Organizations<boolean, boolean>
+>({
+  name: 'organizations',
+  getKey: getOrganizationsCacheKey,
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<Organizations<boolean, boolean>>({
+          uri: '/organizations',
+          query: buildQuery(normalizeOrganizationsOptions(options)),
+          tag: 'organizations.list',
+        }),
+      ),
+    ),
+  tags: (data) => [
+    {type: 'organization', id: 'LIST'},
+    ...data.map((org) => ({type: 'organization', id: org.id})),
+  ],
+})

package/src/project/project.test-d.ts

@@ -2,92 +2,36 @@ import {expectTypeOf, test} from 'vitest'
 
 import {type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {
-  getProjectState,
-  type Project,
-  type ProjectBase,
-  type ProjectMember,
-  resolveProject,
-} from './project'
+import {type FetcherSnapshot} from '../store/fetcherStore'
+import {type Project, project, type ProjectMember} from './project'
 
 const instance = {} as SanityInstance
 
-test('resolveProject — default call: members and features both included by default', () => {
-  expectTypeOf(resolveProject(instance)).resolves.toEqualTypeOf<Project<true, true>>()
-  type Result = Awaited<ReturnType<typeof resolveProject<true, true>>>
-  expectTypeOf<Result['members']>().toEqualTypeOf<ProjectMember[]>()
-})
-
-test('resolveProject — includeMembers: false drops members from the type', () => {
-  expectTypeOf(resolveProject(instance, {includeMembers: false})).resolves.toEqualTypeOf<
-    Project<false, true>
-  >()
-})
-
-test('resolveProject — includeFeatures: false drops features from the type', () => {
-  expectTypeOf(resolveProject(instance, {includeFeatures: false})).resolves.toEqualTypeOf<
-    Project<true, false>
-  >()
-})
-
-test('resolveProject — both flags false → bare base shape', () => {
-  expectTypeOf(
-    resolveProject(instance, {includeMembers: false, includeFeatures: false}),
-  ).resolves.toEqualTypeOf<Project<false, false>>()
-  type Result = Awaited<ReturnType<typeof resolveProject<false, false>>>
-  expectTypeOf<Result['id']>().toEqualTypeOf<string>()
-})
-
-test('resolveProject — rejects non-boolean flag values', () => {
-  // @ts-expect-error — includeMembers must be a boolean
-  void resolveProject(instance, {includeMembers: 'yes'})
-})
-
-test('resolveProject — projectId alone does not change the data shape', () => {
-  expectTypeOf(resolveProject(instance, {projectId: 'p'})).resolves.toEqualTypeOf<
-    Project<true, true>
-  >()
-})
-
-test('resolveProject — non-literal boolean flag makes members optional', () => {
-  const includeMembers = false as boolean
-  expectTypeOf(resolveProject(instance, {includeMembers})).resolves.toEqualTypeOf<
-    Project<boolean, true>
+test('project.resolveState — resolves the wide-boolean detail shape', () => {
+  expectTypeOf(project.resolveState(instance, {projectId: 'p'})).resolves.toEqualTypeOf<
+    Project<boolean, boolean>
   >()
 })
 
-test('getProjectState — default call returns members + features StateSource', () => {
-  expectTypeOf(getProjectState(instance)).toEqualTypeOf<
-    StateSource<Project<true, true> | undefined>
-  >()
+test('Project — literal flags narrow members and features', () => {
+  expectTypeOf<Project<true, true>['members']>().toEqualTypeOf<ProjectMember[]>()
+  expectTypeOf<Project<true, true>['features']>().toEqualTypeOf<string[]>()
+  expectTypeOf<keyof Project<false, false> & ('members' | 'features')>().toEqualTypeOf<never>()
 })
 
-test('getProjectState — both flags false narrows to the bare base shape', () => {
-  expectTypeOf(
-    getProjectState(instance, {includeMembers: false, includeFeatures: false}),
-  ).toEqualTypeOf<StateSource<Project<false, false> | undefined>>()
+test('Project<boolean, boolean> — members and features are optional', () => {
+  type Item = Project<boolean, boolean>
+  expectTypeOf<Item['members']>().toEqualTypeOf<ProjectMember[] | undefined>()
+  expectTypeOf<Item['features']>().toEqualTypeOf<string[] | undefined>()
 })
 
-test('Project — wide boolean for IncludeMembers makes members optional', () => {
-  expectTypeOf<Project<boolean, true>>().toEqualTypeOf<
-    ProjectBase & {members?: ProjectMember[]} & {features: string[]}
+test('project.getState — exposes the snapshot envelope', () => {
+  expectTypeOf(project.getState(instance, {projectId: 'p'})).toEqualTypeOf<
+    StateSource<FetcherSnapshot<Project<boolean, boolean>>>
   >()
-  expectTypeOf<Pick<Project<boolean, true>, 'members'>>().toEqualTypeOf<{
-    members?: ProjectMember[]
-  }>()
 })
 
-test('Project — wide boolean for IncludeFeatures makes features optional', () => {
-  expectTypeOf<Project<true, boolean>>().toEqualTypeOf<
-    ProjectBase & {members: ProjectMember[]} & {features?: string[]}
-  >()
-  expectTypeOf<Pick<Project<true, boolean>, 'features'>>().toEqualTypeOf<{
-    features?: string[]
-  }>()
-})
-
-test('Project — both wide booleans make both fields optional', () => {
-  expectTypeOf<Project<boolean, boolean>>().toEqualTypeOf<
-    ProjectBase & {members?: ProjectMember[]} & {features?: string[]}
-  >()
+test('project — rejects non-boolean flag values', () => {
+  // @ts-expect-error includeMembers must be a boolean
+  void project.resolveState(instance, {includeMembers: 'yes'})
 })

package/src/project/project.test.ts

@@ -3,9 +3,10 @@ import {of} from 'rxjs'
 import {afterEach, beforeEach, describe, it} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
+import {projects} from '../projects/projects'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {getProjectCacheKey, resolveProject} from './project'
+import {getProjectCacheKey, project} from './project'
 
 vi.mock('../client/clientStore')
 
@@ -21,8 +22,8 @@ describe('project', () => {
   })
 
   it('calls `client.observable.request` against `/projects/<id>` and returns the result', async () => {
-    const project = {id: 'a'}
-    const request = vi.fn().mockReturnValue(of(project))
+    const detail = {id: 'a'}
+    const request = vi.fn().mockReturnValue(of(detail))
 
     const mockClient = {
       observable: {request} as unknown as SanityClient['observable'],
@@ -32,12 +33,12 @@ describe('project', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    const result = await resolveProject(instance, {projectId: 'a'})
-    expect(result).toEqual(project)
+    const result = await project.resolveState(instance, {projectId: 'a'})
+    expect(result).toEqual(detail)
     expect(request).toHaveBeenCalledWith({
       uri: '/projects/a',
       query: {includeMembers: 'true', includeFeatures: 'true'},
-      tag: 'project.get',
+      tag: 'projects.get',
     })
   })
 
@@ -51,7 +52,7 @@ describe('project', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    await resolveProject(instance, {
+    await project.resolveState(instance, {
       projectId: 'a',
       includeMembers: false,
       includeFeatures: false,
@@ -63,7 +64,7 @@ describe('project', () => {
         includeMembers: 'false',
         includeFeatures: 'false',
       },
-      tag: 'project.get',
+      tag: 'projects.get',
     })
   })
 
@@ -77,13 +78,59 @@ describe('project', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    await resolveProject(instance)
+    await project.resolveState(instance)
     expect(request).toHaveBeenCalledWith({
       uri: '/projects/p',
       query: {includeMembers: 'true', includeFeatures: 'true'},
-      tag: 'project.get',
+      tag: 'projects.get',
     })
   })
+
+  it('pre-seeds a memberless detail read from the cached default list without fetching', async () => {
+    const request = vi.fn().mockReturnValue(
+      of([
+        {id: 'p1', displayName: 'One'},
+        {id: 'p2', displayName: 'Two'},
+      ]),
+    )
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    await projects.resolveState(instance)
+    expect(request).toHaveBeenCalledTimes(1)
+
+    const source = project.getState(instance, {projectId: 'p1', includeMembers: false})
+    const unsubscribe = source.subscribe()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(source.getCurrent()).toMatchObject({status: 'success', data: {id: 'p1'}})
+    expect(request).toHaveBeenCalledTimes(1)
+    unsubscribe()
+  })
+
+  it('does not pre-seed a detail read that includes members', async () => {
+    const list = [{id: 'p1', displayName: 'One'}]
+    const detail = {id: 'p1', displayName: 'One', members: []}
+    const request = vi.fn().mockReturnValueOnce(of(list)).mockReturnValueOnce(of(detail))
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    await projects.resolveState(instance)
+
+    const result = await project.resolveState(instance, {projectId: 'p1'})
+    expect(result).toEqual(detail)
+    expect(request).toHaveBeenCalledTimes(2)
+  })
 })
 
 describe('project cache key generation', () => {

package/src/project/project.ts

@@ -2,9 +2,10 @@ import {switchMap} from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
 import {type ProjectHandle} from '../config/sanityConfig'
+import {projects} from '../projects/projects'
 import {type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {createFetcherStore} from '../utils/createFetcherStore'
+import {defineFetcher} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
 
 const API_VERSION = 'v2025-02-19'
 
@@ -111,57 +112,37 @@ export function getProjectCacheKey(
   return `project:${projectId}${membersKey}${featuresKey}`
 }
 
-const project = createFetcherStore({
-  name: 'Project',
+/**
+ * Fetcher for a single project (`GET /projects/:id`), on the shared fetcher
+ * cache. Pre-seeds from the default {@link projects} list entry when it can
+ * satisfy the read — the default list carries features but not members, so
+ * only `includeMembers: false` reads seed.
+ *
+ * @internal
+ */
+export const project = defineFetcher<
+  [options?: ProjectOptions<boolean, boolean>],
+  Project<boolean, boolean>
+>({
+  name: 'project',
   getKey: getProjectCacheKey,
-  fetcher: (instance) => (options?: ProjectOptions<boolean, boolean>) => {
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<Project<boolean, boolean>>({
+          uri: `/projects/${resolveProjectId(instance, options)}`,
+          query: buildQuery(normalizeProjectOptions(options)),
+          tag: 'projects.get',
+        }),
+      ),
+    ),
+  tags: (data) => [{type: 'project', id: data.id}],
+  initialData: (instance, options) => {
+    if (normalizeProjectOptions(options).includeMembers) return undefined
+    const snapshot = projects.getState(instance).getCurrent()
+    if (snapshot.status !== 'success') return undefined
     const projectId = resolveProjectId(instance, options)
-
-    return getClientState(instance, {
-      apiVersion: API_VERSION,
-      scope: 'global',
-    }).observable.pipe(
-      switchMap((client) => {
-        const normalized = normalizeProjectOptions(options)
-        const query = Object.fromEntries(
-          Object.entries(normalized)
-            .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => [key, String(value)]),
-        )
-
-        return client.observable.request({
-          uri: `/projects/${projectId}`,
-          query,
-          tag: 'project.get',
-        })
-      }),
-    )
+    const match = snapshot.data.find((item) => item.id === projectId)
+    return match && {data: match, dataUpdatedAt: snapshot.dataUpdatedAt}
   },
 })
-
-/**
- * Public signature for the project state source. The conditional generics
- * cannot flow through `BoundStoreAction`, so we declare the signature here
- * and assign the (already-correct) runtime function to it.
- */
-type GetProjectState = <
-  IncludeMembers extends boolean = true,
-  IncludeFeatures extends boolean = true,
->(
-  instance: SanityInstance,
-  options?: ProjectOptions<IncludeMembers, IncludeFeatures>,
-) => StateSource<Project<IncludeMembers, IncludeFeatures> | undefined>
-
-type ResolveProject = <
-  IncludeMembers extends boolean = true,
-  IncludeFeatures extends boolean = true,
->(
-  instance: SanityInstance,
-  options?: ProjectOptions<IncludeMembers, IncludeFeatures>,
-) => Promise<Project<IncludeMembers, IncludeFeatures>>
-
-/** @public */
-export const getProjectState: GetProjectState = project.getState
-
-/** @public */
-export const resolveProject: ResolveProject = project.resolveState

package/src/projects/projects.test-d.ts

@@ -3,36 +3,30 @@ import {expectTypeOf, test} from 'vitest'
 import {type Project, type ProjectMember} from '../project/project'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {getProjectsState, resolveProjects} from './projects'
+import {type FetcherSnapshot} from '../store/fetcherStore'
+import {projects} from './projects'
 
 const instance = {} as SanityInstance
 
-test('resolveProjects — default call: features included, members omitted', () => {
-  expectTypeOf(resolveProjects(instance)).resolves.toEqualTypeOf<Project<false, true>[]>()
-})
-
-test('resolveProjects — includeMembers: true adds members to the type', () => {
-  expectTypeOf(resolveProjects(instance, {includeMembers: true})).resolves.toEqualTypeOf<
-    Project<true, true>[]
+test('projects.resolveState — resolves the wide-boolean list shape', () => {
+  expectTypeOf(projects.resolveState(instance)).resolves.toEqualTypeOf<
+    Project<boolean, boolean>[]
   >()
-  type Result = Awaited<ReturnType<typeof resolveProjects<true, true>>>
-  expectTypeOf<Result[number]['members']>().toEqualTypeOf<ProjectMember[]>()
 })
 
-test('resolveProjects — includeFeatures: false drops features from the type', () => {
-  expectTypeOf(resolveProjects(instance, {includeFeatures: false})).resolves.toEqualTypeOf<
-    Project<false, false>[]
-  >()
+test('Project<boolean, boolean> — members and features are optional', () => {
+  type Item = Project<boolean, boolean>
+  expectTypeOf<Item['members']>().toEqualTypeOf<ProjectMember[] | undefined>()
+  expectTypeOf<Item['features']>().toEqualTypeOf<string[] | undefined>()
 })
 
-test('resolveProjects — organizationId alone does not change the data shape', () => {
-  expectTypeOf(resolveProjects(instance, {organizationId: 'org_123'})).resolves.toEqualTypeOf<
-    Project<false, true>[]
+test('projects.getState — exposes the snapshot envelope', () => {
+  expectTypeOf(projects.getState(instance)).toEqualTypeOf<
+    StateSource<FetcherSnapshot<Project<boolean, boolean>[]>>
   >()
 })
 
-test('getProjectsState — default call returns features-only StateSource', () => {
-  expectTypeOf(getProjectsState(instance)).toEqualTypeOf<
-    StateSource<Project<false, true>[] | undefined>
-  >()
+test('projects — rejects non-boolean flag values', () => {
+  // @ts-expect-error includeMembers must be a boolean
+  void projects.resolveState(instance, {includeMembers: 'yes'})
 })

package/src/projects/projects.test.ts

@@ -5,7 +5,7 @@ import {afterEach, beforeEach, describe, it} from 'vitest'
 import {getClientState} from '../client/clientStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {getProjectsCacheKey, resolveProjects} from './projects'
+import {getProjectsCacheKey, projects} from './projects'
 
 vi.mock('../client/clientStore')
 
@@ -21,8 +21,8 @@ describe('projects', () => {
   })
 
   it('calls `client.observable.request` against `/projects` and returns the result', async () => {
-    const projects = [{id: 'a'}, {id: 'b'}]
-    const request = vi.fn().mockReturnValue(of(projects))
+    const list = [{id: 'a'}, {id: 'b'}]
+    const request = vi.fn().mockReturnValue(of(list))
 
     const mockClient = {
       observable: {request} as unknown as SanityClient['observable'],
@@ -32,12 +32,12 @@ describe('projects', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    const result = await resolveProjects(instance)
-    expect(result).toEqual(projects)
+    const result = await projects.resolveState(instance)
+    expect(result).toEqual(list)
     expect(request).toHaveBeenCalledWith({
       uri: '/projects',
       query: {includeMembers: 'false', includeFeatures: 'true', onlyExplicitMembership: 'false'},
-      tag: 'projects.get',
+      tag: 'projects.list',
     })
   })
 
@@ -51,7 +51,7 @@ describe('projects', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    await resolveProjects(instance, {
+    await projects.resolveState(instance, {
       organizationId: 'org123',
       includeMembers: true,
       includeFeatures: false,
@@ -65,7 +65,7 @@ describe('projects', () => {
         includeFeatures: 'false',
         onlyExplicitMembership: 'false',
       },
-      tag: 'projects.get',
+      tag: 'projects.list',
     })
   })
 })

package/src/projects/projects.ts

@@ -3,8 +3,8 @@ import {switchMap} from 'rxjs'
 import {getClientState} from '../client/clientStore'
 import {type Project} from '../project/project'
 import {type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {createFetcherStore} from '../utils/createFetcherStore'
+import {defineFetcher} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
 
 const API_VERSION = 'v2025-02-19'
 
@@ -42,54 +42,30 @@ export function getProjectsCacheKey(
   return `projects${orgKey}${membersKey}${featuresKey}${explicitKey}`
 }
 
-const projects = createFetcherStore({
-  name: 'Projects',
+/**
+ * Fetcher for the current user's projects (`GET /projects`), on the shared
+ * fetcher cache.
+ *
+ * @internal
+ */
+export const projects = defineFetcher<
+  [options?: ProjectsOptions<boolean, boolean>],
+  Project<boolean, boolean>[]
+>({
+  name: 'projects',
   getKey: getProjectsCacheKey,
-  fetcher: (instance) => (options?: ProjectsOptions<boolean, boolean>) =>
-    getClientState(instance, {
-      apiVersion: API_VERSION,
-      scope: 'global',
-    }).observable.pipe(
-      switchMap((client) => {
-        const normalized = normalizeProjectsOptions(options)
-        const query = Object.fromEntries(
-          Object.entries(normalized)
-            .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => [key, String(value)]),
-        )
-
-        return client.observable.request({
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<Project<boolean, boolean>[]>({
           uri: '/projects',
-          query,
-          tag: 'projects.get',
-        })
-      }),
+          query: buildQuery(normalizeProjectsOptions(options)),
+          tag: 'projects.list',
+        }),
+      ),
     ),
+  tags: (data) => [
+    {type: 'project', id: 'LIST'},
+    ...data.map((project) => ({type: 'project', id: project.id})),
+  ],
 })
-
-/**
- * Public signature for the projects state source. The conditional generics
- * cannot flow through `BoundStoreAction`, so we declare the signature here
- * and assign the (already-correct) runtime function to it.
- */
-type GetProjectsState = <
-  IncludeMembers extends boolean = false,
-  IncludeFeatures extends boolean = true,
->(
-  instance: SanityInstance,
-  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
-) => StateSource<Project<IncludeMembers, IncludeFeatures>[] | undefined>
-
-type ResolveProjects = <
-  IncludeMembers extends boolean = false,
-  IncludeFeatures extends boolean = true,
->(
-  instance: SanityInstance,
-  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
-) => Promise<Project<IncludeMembers, IncludeFeatures>[]>
-
-/** @public */
-export const getProjectsState: GetProjectsState = projects.getState
-
-/** @public */
-export const resolveProjects: ResolveProjects = projects.resolveState