diff --git a/apps/web/app/space/[id]/(space)/claims/claims-page-client.test.tsx b/apps/web/app/space/[id]/(space)/claims/claims-page-client.test.tsx
index 2e678bbb50..026d0a5815 100644
--- a/apps/web/app/space/[id]/(space)/claims/claims-page-client.test.tsx
+++ b/apps/web/app/space/[id]/(space)/claims/claims-page-client.test.tsx
@@ -1,10 +1,13 @@
 import { SystemIds } from '@geoprotocol/geo-sdk/lite';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import '@testing-library/jest-dom/vitest';
-import { cleanup, fireEvent, render, screen, within } from '@testing-library/react';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { CLAIM_TYPE_ID, TOPICS_PROPERTY_ID } from '~/core/claims/ontology';
+import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID, TOPICS_PROPERTY_ID } from '~/core/claims/ontology';
 import type { Entity, Relation } from '~/core/types';
 
 import { ClaimsPageClient } from './claims-page-client';
@@ -17,13 +20,19 @@ const mocks = vi.hoisted(() => ({
   bumpReviewVersion: vi.fn(),
   setIsReviewOpen: vi.fn(),
   joinMutate: vi.fn(),
+  leaveMutate: vi.fn(),
+  responseBatchCalls: [] as unknown[],
+  refetchResponseBatch: vi.fn(),
 }));
 
 let claims: Entity[] = [];
+let claimsLoading = false;
 let featureEnabled = true;
 let joinPending = false;
 let lastQueryEntitiesOptions: unknown = null;
 let debateClaimsResponse: { claims: unknown[] } = { claims: [] };
+let responseBatchReady = true;
+let responseBatchError = false;
 
 vi.mock('next/navigation', () => ({
   useRouter: () => ({ replace: mocks.replace, push: vi.fn() }),
@@ -33,13 +42,49 @@ vi.mock('~/core/state/feature-flags', () => ({
   useDebatesEnabled: () => featureEnabled,
 }));
 
+vi.mock('~/core/hooks/use-entity-vote', () => ({
+  useEntityResponseIndexingState: () => 'idle',
+  useEntityResponseIndexingSnapshot: () => ({ status: 'idle', pending: null, runId: null }),
+  useResetEntityResponseIndexingSnapshot: () => vi.fn(),
+}));
+
 vi.mock('~/core/debates/hooks', () => ({
+  useGeoChatAuth: () => ({ authenticated: true, accountKey: 'account-1' }),
   useDebateClaims: () => ({ data: debateClaimsResponse, error: null }),
-  useJoinDebateQueue: () => ({ mutate: mocks.joinMutate, isPending: joinPending, error: null }),
+  useJoinDebateQueue: () => ({
+    mutateAsync: mocks.joinMutate,
+    reset: vi.fn(),
+    isPending: joinPending,
+    error: null,
+  }),
+  useLeaveDebateQueue: () => ({ mutateAsync: mocks.leaveMutate, isPending: false, error: null }),
   useAcceptDebateMatch: () => ({ mutate: vi.fn(), isPending: false, error: null }),
   useDeclineDebateMatch: () => ({ mutate: vi.fn(), isPending: false, error: null }),
 }));
 
+vi.mock('~/core/responses/use-claim-response-summaries', () => ({
+  ClaimResponseBatchBoundary: ({ children }: { children: ReactNode }) => <>{children}</>,
+  useClaimResponseSummaryBatch: (options: unknown) => {
+    mocks.responseBatchCalls.push(options);
+    return {
+      isSuccess: responseBatchReady,
+      isError: responseBatchError,
+      refetch: mocks.refetchResponseBatch,
+    };
+  },
+}));
+
+vi.mock('~/partials/entity-page/entity-vote-buttons', () => ({
+  EntityVoteButtons: ({ responseKind }: { responseKind: string }) =>
+    !responseBatchReady ? (
+      <div data-testid="entity-response-skeleton">Response skeleton</div>
+    ) : (
+      <div data-testid="entity-response-buttons" data-response-kind={responseKind}>
+        Entity response buttons
+      </div>
+    ),
+}));
+
 vi.mock('~/core/state/diff-store', () => ({
   useDiff: () => ({
     setActiveSpace: mocks.setActiveSpace,
@@ -51,7 +96,8 @@ vi.mock('~/core/state/diff-store', () => ({
 vi.mock('~/core/sync/use-store', () => ({
   useQueryEntities: (options: unknown) => {
     lastQueryEntitiesOptions = options;
-    return { entities: claims, isLoading: false };
+    const deferUntilFetched = (options as { deferUntilFetched?: boolean }).deferUntilFetched;
+    return { entities: claimsLoading && deferUntilFetched ? [] : claims, isLoading: claimsLoading };
   },
 }));
 
@@ -72,18 +118,24 @@ vi.mock('~/design-system/select-entity-compact', () => ({
 
 beforeEach(() => {
   claims = [];
+  claimsLoading = false;
   featureEnabled = true;
   joinPending = false;
   lastQueryEntitiesOptions = null;
   debateClaimsResponse = { claims: [] };
+  responseBatchReady = true;
+  responseBatchError = false;
   vi.clearAllMocks();
+  mocks.joinMutate.mockReturnValue(new Promise(() => undefined));
+  mocks.leaveMutate.mockReturnValue(new Promise(() => undefined));
+  mocks.responseBatchCalls.length = 0;
 });
 
 afterEach(() => cleanup());
 
 describe('ClaimsPageClient', () => {
   it('queries Claim entities and renders the empty state', () => {
-    render(<ClaimsPageClient spaceId="space-1" />);
+    renderClaims();
 
     expect(screen.getByRole('heading', { name: 'Claims' })).toBeInTheDocument();
     expect(screen.getByText('No claims yet')).toBeInTheDocument();
@@ -92,11 +144,38 @@ describe('ClaimsPageClient', () => {
         spaces: [{ equals: 'space-1' }],
         types: [{ id: { equals: CLAIM_TYPE_ID } }],
       },
+      deferUntilFetched: true,
+      includeUnpublishedLocal: true,
     });
+    expect(lastQueryEntitiesOptions).not.toHaveProperty('placeholderData');
+  });
+
+  it('shows loading instead of locally cached claims before the authoritative query resolves', () => {
+    claims = [publishedClaim()];
+    claimsLoading = true;
+
+    renderClaims();
+
+    expect(screen.getByText('Loading claims...')).toBeInTheDocument();
+    expect(screen.queryByText('Public transit should be free')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('entity-response-buttons')).not.toBeInTheDocument();
+    expect(screen.queryByRole('switch', { name: 'Debate' })).not.toBeInTheDocument();
+  });
+
+  it('does not retain the previous space claims while the next space loads', () => {
+    claims = [publishedClaim()];
+    const view = renderClaims();
+    expect(screen.getByText('Public transit should be free')).toBeInTheDocument();
+
+    claimsLoading = true;
+    view.rerender(<ClaimsPageClient spaceId="space-2" />);
+
+    expect(screen.getByText('Loading claims...')).toBeInTheDocument();
+    expect(screen.queryByText('Public transit should be free')).not.toBeInTheDocument();
   });
 
   it('stages a claim with Claim and Topics relations only', () => {
-    render(<ClaimsPageClient spaceId="space-1" />);
+    renderClaims();
 
     fireEvent.click(screen.getByRole('button', { name: 'Add claim' }));
     fireEvent.change(screen.getByLabelText('Claim'), {
@@ -112,142 +191,137 @@ describe('ClaimsPageClient', () => {
     expect(mocks.setIsReviewOpen).toHaveBeenCalledWith(true);
   });
 
-  it('joins the claim queue with boolean Yes and No positions', () => {
-    claims = [
-      {
-        id: 'claim-1',
-        name: 'Public transit should be free',
-        description: null,
-        spaces: ['space-1'],
-        types: [{ id: CLAIM_TYPE_ID, name: 'Claim' }],
-        values: [],
-        relations: [],
-      },
-    ];
+  it('enables the readiness switch after a refetch exposes the viewer response', () => {
+    claims = [publishedClaim()];
     debateClaimsResponse = {
-      claims: [
-        {
-          claim_entity_id: 'claim-1',
-          viewer_waiting_position: null,
-          online_choices: [],
-          active_match: null,
-          active_debate: null,
-        },
-      ],
+      claims: [debateClaim({ viewer_response: null })],
+    };
+
+    const { rerender } = renderClaims();
+
+    expect(screen.getByTestId('entity-response-buttons')).toBeInTheDocument();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
+
+    debateClaimsResponse = {
+      claims: [debateClaim({ viewer_response: { position: true, position_label: 'Agree' } })],
     };
+    rerender(<ClaimsPageClient spaceId="space-1" />);
 
-    render(<ClaimsPageClient spaceId="space-1" />);
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
 
-    fireEvent.click(screen.getByRole('button', { name: 'Yes, 0 participants available' }));
-    fireEvent.click(screen.getByRole('button', { name: 'No, 0 participants available' }));
+    expect(mocks.joinMutate).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
 
-    expect(mocks.joinMutate).toHaveBeenCalledWith({ claimId: 'claim-1', request: { position: true } });
-    expect(mocks.joinMutate).toHaveBeenCalledWith({ claimId: 'claim-1', request: { position: false } });
+  it('batches the active response kind for all visible claims and defers their individual requests', () => {
+    claims = Array.from({ length: 50 }, (_, index) => publishedClaim(`claim-${index}`, `Claim ${index}`));
+    debateClaimsResponse = {
+      claims: claims.map((claim, index) =>
+        debateClaim({
+          claim_entity_id: claim.id,
+          response_kind: index % 2 === 0 ? 'stance' : 'veracity',
+        })
+      ),
+    };
+    responseBatchReady = false;
+
+    renderClaims();
+
+    expect(mocks.responseBatchCalls).toHaveLength(1);
+    expect(mocks.responseBatchCalls[0]).toMatchObject({
+      spaceId: 'space-1',
+      enabled: true,
+      targets: expect.arrayContaining([
+        { entityId: 'claim-0', responseKind: 'stance' },
+        { entityId: 'claim-1', responseKind: 'veracity' },
+      ]),
+    });
+    expect((mocks.responseBatchCalls[0] as { targets: unknown[] }).targets).toHaveLength(50);
+    expect(screen.getAllByTestId('entity-response-skeleton')).toHaveLength(50);
+    expect(screen.queryByTestId('entity-response-buttons')).not.toBeInTheDocument();
+    expect(screen.getAllByRole('switch', { name: 'Debate' })).toHaveLength(50);
   });
 
-  it('renders online participants and highlights the viewer selected position', () => {
+  it('keeps every published claim responsive when geo-chat has not hydrated its readiness snapshot yet', () => {
     claims = [
+      publishedClaim('claim-1', 'Existing debate claim'),
       {
-        id: 'claim-1',
-        name: 'Public transit should be free',
-        description: null,
-        spaces: ['space-1'],
-        types: [{ id: CLAIM_TYPE_ID, name: 'Claim' }],
-        values: [],
-        relations: [],
-      },
+        ...publishedClaim('claim-2', 'New factual claim'),
+        values: [
+          {
+            spaceId: 'space-1',
+            property: { id: CLAIM_IS_FACTUAL_PROPERTY_ID },
+            value: '1',
+          },
+        ],
+      } as Entity,
     ];
-    debateClaimsResponse = {
-      claims: [
-        {
-          claim_entity_id: 'claim-1',
-          viewer_waiting_position: true,
-          online_choices: [
-            {
-              position: true,
-              position_label: 'Yes',
-              participant_count: 4,
-              participants: [
-                {
-                  user_id: 'viewer-user',
-                  profile_space_id: 'viewer-profile',
-                  display_name: 'Current viewer',
-                  avatar_cid: 'https://example.com/viewer.png',
-                },
-                {
-                  user_id: 'other-user',
-                  profile_space_id: 'other-profile',
-                  display_name: 'Other participant',
-                  avatar_cid: null,
-                },
-              ],
-            },
-            {
-              position: false,
-              position_label: 'No',
-              participant_count: 0,
-              participants: [],
-            },
-          ],
-          active_match: null,
-          active_debate: null,
-        },
+    debateClaimsResponse = { claims: [debateClaim()] };
+
+    renderClaims();
+
+    expect(mocks.responseBatchCalls.at(-1)).toMatchObject({
+      targets: [
+        { entityId: 'claim-1', responseKind: 'stance' },
+        { entityId: 'claim-2', responseKind: 'veracity' },
       ],
-    };
+    });
+    expect(screen.getAllByTestId('entity-response-buttons')).toHaveLength(2);
+    expect(screen.getAllByTestId('entity-response-buttons')[1]).toHaveAttribute('data-response-kind', 'veracity');
+    expect(screen.getAllByRole('switch', { name: 'Debate' })).toHaveLength(2);
+    expect(screen.getAllByRole('switch', { name: 'Debate' })[1]).toBeDisabled();
+  });
 
-    render(<ClaimsPageClient spaceId="space-1" />);
-
-    const yesButton = screen.getByRole('button', { name: 'Yes, 4 participants available, selected' });
-    const noButton = screen.getByRole('button', { name: 'No, 0 participants available' });
-
-    expect(yesButton.parentElement).toHaveClass('grid-cols-2');
-    expect(yesButton).toHaveClass('rounded-full', 'bg-green');
-    expect(yesButton).toHaveAttribute('aria-pressed', 'true');
-    expect(yesButton).toBeDisabled();
-    expect(noButton).not.toHaveClass('bg-green');
-    expect(noButton).toHaveAttribute('aria-pressed', 'false');
-    expect(noButton).toBeEnabled();
-    expect(within(yesButton).getByTitle('Current viewer')).toBeInTheDocument();
-    expect(within(yesButton).getByTitle('Other participant')).toBeInTheDocument();
-    expect(within(yesButton).getByText('+2')).toBeInTheDocument();
-    expect(within(yesButton).queryByRole('list')).not.toBeInTheDocument();
-    expect(yesButton.querySelector('li')).not.toBeInTheDocument();
-    expect(within(noButton).queryByRole('img')).not.toBeInTheDocument();
+  it('retries only the page response batch after its retries are exhausted', () => {
+    claims = [publishedClaim()];
+    debateClaimsResponse = { claims: [debateClaim()] };
+    responseBatchReady = false;
+    responseBatchError = true;
+
+    renderClaims();
+
+    expect(screen.getByTestId('entity-response-skeleton')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
+    expect(mocks.refetchResponseBatch).toHaveBeenCalledOnce();
   });
 
-  it('keeps position controls disabled while joining, unpublished, or matched', () => {
-    const publishedClaim: Entity = {
-      id: 'claim-1',
-      name: 'Public transit should be free',
-      description: null,
-      spaces: ['space-1'],
-      types: [{ id: CLAIM_TYPE_ID, name: 'Claim' }],
-      values: [],
-      relations: [],
-    };
-    claims = [publishedClaim];
+  it('renders backend response labels and one leave-readiness toggle', () => {
+    claims = [publishedClaim()];
     debateClaimsResponse = {
       claims: [
-        {
-          claim_entity_id: 'claim-1',
-          viewer_waiting_position: null,
+        debateClaim({
+          viewer_response: { position: true, position_label: 'Verify' },
+          viewer_debate_ready: true,
+          response_kind: 'veracity',
           online_choices: [],
-          active_match: null,
-          active_debate: null,
-        },
+        }),
       ],
     };
+
+    renderClaims();
+
+    expect(screen.queryByText('Ready to debate')).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    expect(mocks.leaveMutate).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
+
+  it('keeps readiness clickable while joining but unavailable for unpublished or matched claims', () => {
+    const published = publishedClaim();
+    claims = [published];
+    debateClaimsResponse = {
+      claims: [debateClaim()],
+    };
     joinPending = true;
 
-    const { rerender } = render(<ClaimsPageClient spaceId="space-1" />);
+    const { rerender } = renderClaims();
 
-    expect(screen.getByRole('button', { name: 'Yes, 0 participants available' })).toBeDisabled();
-    expect(screen.getByRole('button', { name: 'No, 0 participants available' })).toBeDisabled();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeEnabled();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-busy', 'true');
 
     joinPending = false;
     claims = [
       {
-        ...publishedClaim,
+        ...published,
         relations: [
           {
             type: { id: 'local-change', name: 'Local change' },
@@ -260,25 +334,57 @@ describe('ClaimsPageClient', () => {
     rerender(<ClaimsPageClient spaceId="space-1" />);
 
     expect(screen.getByText('Publish this claim before starting a debate.')).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: 'Yes, 0 participants available' })).toBeDisabled();
-    expect(screen.getByRole('button', { name: 'No, 0 participants available' })).toBeDisabled();
+    expect(screen.queryByRole('switch', { name: 'Debate' })).not.toBeInTheDocument();
 
-    claims = [publishedClaim];
+    claims = [published];
     debateClaimsResponse = {
-      claims: [
-        {
-          claim_entity_id: 'claim-1',
-          viewer_waiting_position: null,
-          online_choices: [],
-          active_match: { id: 'match-1' },
-          active_debate: null,
-        },
-      ],
+      claims: [debateClaim({ active_match: { id: 'match-1' } })],
     };
     rerender(<ClaimsPageClient spaceId="space-1" />);
 
     expect(screen.getByText('Match found. Both speakers need to accept.')).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: 'Yes, 0 participants available' })).toBeDisabled();
-    expect(screen.getByRole('button', { name: 'No, 0 participants available' })).toBeDisabled();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
   });
 });
+
+function renderClaims() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(<ClaimsPageClient spaceId="space-1" />, {
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  });
+}
+
+function publishedClaim(id = 'claim-1', name = 'Public transit should be free'): Entity {
+  return {
+    id,
+    name,
+    description: null,
+    spaces: ['space-1'],
+    types: [{ id: CLAIM_TYPE_ID, name: 'Claim' }],
+    values: [],
+    relations: [],
+  };
+}
+
+function debateClaim(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'debate-claim-1',
+    space_id: 'space-1',
+    claim_entity_id: 'claim-1',
+    claim: 'Public transit should be free',
+    description: null,
+    response_kind: 'stance',
+    viewer_response: { position: true, position_label: 'Agree' },
+    viewer_debate_ready: false,
+    readiness_disabled_reason: null,
+    readiness_changed_at: null,
+    online_choices: [],
+    active_match: null,
+    active_debate: null,
+    created_at: '2026-08-06T00:00:00.000Z',
+    updated_at: '2026-08-06T00:00:00.000Z',
+    ...overrides,
+  };
+}
diff --git a/apps/web/app/space/[id]/(space)/claims/claims-page-client.tsx b/apps/web/app/space/[id]/(space)/claims/claims-page-client.tsx
index b8b3a9af39..2669c6065f 100644
--- a/apps/web/app/space/[id]/(space)/claims/claims-page-client.tsx
+++ b/apps/web/app/space/[id]/(space)/claims/claims-page-client.tsx
@@ -1,26 +1,30 @@
 'use client';
 
-import { keepPreviousData } from '@tanstack/react-query';
-
 import * as React from 'react';
 
 import cx from 'classnames';
 import { useRouter } from 'next/navigation';
 
 import { buildClaimDraft } from '~/core/claims/claim-draft';
-import { CLAIM_TYPE_ID, TOPICS_PROPERTY_ID, TOPIC_TYPE_ID } from '~/core/claims/ontology';
+import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID, TOPICS_PROPERTY_ID, TOPIC_TYPE_ID } from '~/core/claims/ontology';
 import { isClaimPublished } from '~/core/claims/publish';
-import type { DebateClaim, DebateOnlineChoice } from '~/core/debates/api';
-import { useDebateClaims, useJoinDebateQueue } from '~/core/debates/hooks';
+import type { DebateClaim } from '~/core/debates/api';
+import { ClaimDebateReadiness } from '~/core/debates/claim-debate-readiness';
+import { DebateEntityResponseControls } from '~/core/debates/debate-entity-response-controls';
+import { useDebateClaims } from '~/core/debates/hooks';
+import { uuidToHex } from '~/core/id/normalize';
+import {
+  ClaimResponseBatchBoundary,
+  useClaimResponseSummaryBatch,
+} from '~/core/responses/use-claim-response-summaries';
 import { useDiff } from '~/core/state/diff-store';
 import { useDebatesEnabled } from '~/core/state/feature-flags';
 import { useMutate } from '~/core/sync/use-mutate';
 import { useQueryEntities } from '~/core/sync/use-store';
 import type { Entity, Relation } from '~/core/types';
 
-import { Avatar } from '~/design-system/avatar';
 import { Button } from '~/design-system/button';
-import { Check } from '~/design-system/icons/check';
+import { getChecked } from '~/design-system/checkbox';
 import { Plus } from '~/design-system/icons/plus';
 import { SelectEntityCompact, type SelectEntityCompactResult } from '~/design-system/select-entity-compact';
 import { Text } from '~/design-system/text';
@@ -70,7 +74,7 @@ function ClaimsTabSurface({ spaceId, debatesEnabled }: ClaimsPageClientProps & {
       types: [{ id: { equals: CLAIM_TYPE_ID } }],
     },
     first: 50,
-    placeholderData: keepPreviousData,
+    deferUntilFetched: true,
     includeUnpublishedLocal: true,
   });
   const publishedClaimIds = React.useMemo(() => claims.filter(isClaimPublished).map(claim => claim.id), [claims]);
@@ -86,6 +90,28 @@ function ClaimsTabSurface({ spaceId, debatesEnabled }: ClaimsPageClientProps & {
     () => (debateClaimsQuery.data?.claims ?? []).flatMap(claim => (claim.active_match ? [claim.active_match] : [])),
     [debateClaimsQuery.data?.claims]
   );
+  const responseKindsByEntityId = React.useMemo(
+    () =>
+      new Map(
+        claims
+          .filter(isClaimPublished)
+          .map(claim => [
+            claim.id,
+            debateClaimsByEntityId.get(claim.id)?.response_kind ?? claimResponseKind(claim, spaceId),
+          ])
+      ),
+    [claims, debateClaimsByEntityId, spaceId]
+  );
+  const responseTargets = React.useMemo(
+    () => publishedClaimIds.map(entityId => ({ entityId, responseKind: responseKindsByEntityId.get(entityId)! })),
+    [publishedClaimIds, responseKindsByEntityId]
+  );
+  const responseBatch = useClaimResponseSummaryBatch({
+    spaceId,
+    targets: responseTargets,
+    enabled: debatesEnabled,
+  });
+  const responseBatchReady = responseTargets.length === 0 || responseBatch.isSuccess;
   return (
     <div className="py-8">
       <div className="mb-5 flex flex-wrap items-center justify-between gap-3">
@@ -102,15 +128,26 @@ function ClaimsTabSurface({ spaceId, debatesEnabled }: ClaimsPageClientProps & {
       {formOpen && <AddClaimForm spaceId={spaceId} onCancel={() => setFormOpen(false)} />}
 
       <div className={cx(formOpen && 'mt-6')}>
-        <ClaimsList
-          claims={claims}
-          isLoading={isLoading}
-          spaceId={spaceId}
-          debatesEnabled={debatesEnabled}
-          debateJoinBlocked={activeMatches.length > 0}
-          debateClaimsByEntityId={debateClaimsByEntityId}
-          debateStatus={debateClaimsQuery.error instanceof Error ? debateClaimsQuery.error.message : null}
-        />
+        <ClaimResponseBatchBoundary ready={responseBatchReady}>
+          {responseBatch.isError ? (
+            <div className="mb-3 flex items-center justify-between gap-3 rounded-lg border border-grey-02 bg-white px-5 py-3">
+              <Text color="grey-04">Response data could not be loaded.</Text>
+              <Button type="button" variant="secondary" onClick={() => void responseBatch.refetch()}>
+                Retry
+              </Button>
+            </div>
+          ) : null}
+          <ClaimsList
+            claims={claims}
+            isLoading={isLoading}
+            spaceId={spaceId}
+            debatesEnabled={debatesEnabled}
+            debateJoinBlocked={activeMatches.length > 0}
+            debateClaimsByEntityId={debateClaimsByEntityId}
+            responseKindsByEntityId={responseKindsByEntityId}
+            debateStatus={debateClaimsQuery.error instanceof Error ? debateClaimsQuery.error.message : null}
+          />
+        </ClaimResponseBatchBoundary>
       </div>
     </div>
   );
@@ -228,6 +265,7 @@ function ClaimsList({
   debatesEnabled,
   debateJoinBlocked,
   debateClaimsByEntityId,
+  responseKindsByEntityId,
   debateStatus,
 }: {
   claims: Entity[];
@@ -236,6 +274,7 @@ function ClaimsList({
   debatesEnabled: boolean;
   debateJoinBlocked: boolean;
   debateClaimsByEntityId: Map<string, DebateClaim>;
+  responseKindsByEntityId: Map<string, 'stance' | 'veracity'>;
   debateStatus: string | null;
 }) {
   if (isLoading && claims.length === 0) {
@@ -274,6 +313,7 @@ function ClaimsList({
           debatesEnabled={debatesEnabled}
           debateJoinBlocked={debateJoinBlocked}
           debateClaim={debateClaimsByEntityId.get(claim.id) ?? null}
+          responseKind={responseKindsByEntityId.get(claim.id) ?? claimResponseKind(claim, spaceId)}
         />
       ))}
     </div>
@@ -286,28 +326,19 @@ function ClaimListItem({
   debatesEnabled,
   debateJoinBlocked,
   debateClaim,
+  responseKind,
 }: {
   claim: Entity;
   spaceId: string;
   debatesEnabled: boolean;
   debateJoinBlocked: boolean;
   debateClaim: DebateClaim | null;
+  responseKind: 'stance' | 'veracity';
 }) {
   const topics = relationsForProperty(claim.relations, TOPICS_PROPERTY_ID);
   const published = isClaimPublished(claim);
-  const joinQueue = useJoinDebateQueue(spaceId);
   const activeMatch = debateClaim?.active_match ?? null;
   const activeDebate = debateClaim?.active_debate ?? null;
-  const mutationError = joinQueue.error instanceof Error ? joinQueue.error.message : null;
-
-  const joinPosition = (position: boolean) => {
-    joinQueue.mutate({
-      claimId: claim.id,
-      request: {
-        position,
-      },
-    });
-  };
 
   return (
     <article className="rounded-lg border border-grey-02 bg-white px-5 py-4 shadow-light">
@@ -323,20 +354,21 @@ function ClaimListItem({
         )}
       </div>
 
-      <PositionButtonGroup
-        debatesEnabled={debatesEnabled}
-        canJoinDebate={published && !activeDebate && !activeMatch && !debateJoinBlocked}
-        pendingPosition={debateClaim?.viewer_waiting_position ?? null}
-        onlineChoices={debateClaim?.online_choices ?? []}
-        joinPending={joinQueue.isPending}
-        onJoinPosition={joinPosition}
-        className="mt-3"
-      />
-
-      {debatesEnabled && (
-        <ClaimDebateStatus debateClaim={debateClaim} mutationError={mutationError} published={published} />
+      {debatesEnabled && published && (
+        <div className="mt-3 flex items-center gap-4">
+          <DebateEntityResponseControls entityId={claim.id} spaceId={spaceId} responseKind={responseKind} />
+          <ClaimDebateReadiness
+            compact
+            debateClaim={debateClaim}
+            entityId={claim.id}
+            spaceId={spaceId}
+            canEnable={!activeDebate && !activeMatch && !debateJoinBlocked}
+          />
+        </div>
       )}
 
+      {debatesEnabled && <ClaimDebateStatus debateClaim={debateClaim} published={published} />}
+
       {topics.length > 0 && (
         <div className="mt-3 grid gap-2 md:grid-cols-3">
           <RelationChipGroup label="Topics" relations={topics} />
@@ -346,129 +378,7 @@ function ClaimListItem({
   );
 }
 
-function PositionButtonGroup({
-  debatesEnabled,
-  canJoinDebate,
-  pendingPosition,
-  onlineChoices,
-  joinPending,
-  onJoinPosition,
-  className,
-}: {
-  debatesEnabled: boolean;
-  canJoinDebate: boolean;
-  pendingPosition: boolean | null;
-  onlineChoices: DebateOnlineChoice[];
-  joinPending: boolean;
-  onJoinPosition: (position: boolean) => void;
-  className?: string;
-}) {
-  const positions = [
-    { label: 'Yes', value: true },
-    { label: 'No', value: false },
-  ];
-
-  return (
-    <div className={className}>
-      <Text as="div" variant="metadataMedium" color="grey-04" className="mb-1">
-        Position
-      </Text>
-      <div className="grid grid-cols-2 gap-2">
-        {positions.map(position => {
-          const choice = onlineChoices.find(choice => choice.position === position.value);
-          const label = choice?.position_label ?? position.label;
-          const participantCount = choice?.participant_count ?? 0;
-          const selected = pendingPosition === position.value;
-          const accessibleLabel = `${label}, ${participantCount} participant${participantCount === 1 ? '' : 's'} available${selected ? ', selected' : ''}`;
-
-          if (debatesEnabled) {
-            return (
-              <button
-                key={position.label}
-                type="button"
-                aria-label={accessibleLabel}
-                aria-pressed={selected}
-                onClick={() => onJoinPosition(position.value)}
-                disabled={!canJoinDebate || joinPending || selected}
-                className={cx(
-                  'flex min-h-11 min-w-0 items-center justify-between gap-2 rounded-full px-3 text-button transition-colors disabled:opacity-60 sm:px-4',
-                  selected ? 'bg-green text-text' : 'bg-bg text-text'
-                )}
-              >
-                <span className="flex min-w-0 items-center gap-1.5">
-                  {selected && (
-                    <span aria-hidden="true" className="shrink-0">
-                      <Check />
-                    </span>
-                  )}
-                  <span className="truncate">{label}</span>
-                </span>
-                {choice && <OnlineChoiceParticipants choice={choice} />}
-              </button>
-            );
-          }
-
-          return (
-            <span
-              key={position.label}
-              className="inline-flex max-w-full items-center rounded-md border border-grey-02 bg-bg px-2 py-1 text-[0.8125rem] text-text"
-            >
-              <span className="truncate">{label}</span>
-            </span>
-          );
-        })}
-      </div>
-    </div>
-  );
-}
-
-function OnlineChoiceParticipants({ choice }: { choice: DebateOnlineChoice }) {
-  const participants = choice.participants.slice(0, 2);
-  const overflowCount = Math.max(0, choice.participant_count - participants.length);
-
-  if (participants.length === 0 && overflowCount === 0) return null;
-
-  return (
-    <span aria-hidden="true" className="flex shrink-0 items-center -space-x-2">
-      {participants.map(participant => {
-        const label = participant.display_name || participant.profile_space_id;
-
-        return (
-          <span
-            key={participant.user_id}
-            title={label}
-            className="relative box-content block h-5 w-5 overflow-hidden rounded-full border-2 border-white"
-          >
-            <Avatar avatarUrl={participant.avatar_cid} value={participant.profile_space_id} alt={label} size={20} />
-          </span>
-        );
-      })}
-      {overflowCount > 0 && (
-        <span className="relative box-content flex h-5 min-w-5 items-center justify-center rounded-full border-2 border-white bg-grey-02 px-1 text-[11px] leading-5 text-grey-04 tabular-nums">
-          +{overflowCount}
-        </span>
-      )}
-    </span>
-  );
-}
-
-function ClaimDebateStatus({
-  debateClaim,
-  mutationError,
-  published,
-}: {
-  debateClaim: DebateClaim | null;
-  mutationError: string | null;
-  published: boolean;
-}) {
-  if (mutationError) {
-    return (
-      <Text as="p" variant="body" color="red-01" className="mt-3">
-        {mutationError}
-      </Text>
-    );
-  }
-
+function ClaimDebateStatus({ debateClaim, published }: { debateClaim: DebateClaim | null; published: boolean }) {
   if (!published) return null;
 
   if (debateClaim?.active_debate) {
@@ -487,14 +397,6 @@ function ClaimDebateStatus({
     );
   }
 
-  if (debateClaim?.viewer_waiting_position !== null && debateClaim?.viewer_waiting_position !== undefined) {
-    return (
-      <Text as="p" variant="body" color="grey-04" className="mt-3">
-        Waiting for someone with the opposite position.
-      </Text>
-    );
-  }
-
   return null;
 }
 
@@ -531,3 +433,13 @@ function RelationChipGroup({
 function relationsForProperty(relations: Relation[], propertyId: string): Relation[] {
   return relations.filter(relation => relation.type.id === propertyId && relation.isDeleted !== true);
 }
+
+function claimResponseKind(claim: Entity, spaceId: string): 'stance' | 'veracity' {
+  const isFactual = claim.values.find(
+    value =>
+      value.isDeleted !== true &&
+      uuidToHex(value.spaceId) === uuidToHex(spaceId) &&
+      uuidToHex(value.property.id) === uuidToHex(CLAIM_IS_FACTUAL_PROPERTY_ID)
+  )?.value;
+  return getChecked(isFactual) === true ? 'veracity' : 'stance';
+}
diff --git a/apps/web/app/space/[id]/(space)/debates/[debateId]/debate-room-page-client.test.tsx b/apps/web/app/space/[id]/(space)/debates/[debateId]/debate-room-page-client.test.tsx
index 09a2b438f2..9597ef1dc4 100644
--- a/apps/web/app/space/[id]/(space)/debates/[debateId]/debate-room-page-client.test.tsx
+++ b/apps/web/app/space/[id]/(space)/debates/[debateId]/debate-room-page-client.test.tsx
@@ -3136,6 +3136,7 @@ function completedDebate(): Debate {
       description: null,
     },
     status: 'complete',
+    response_kind: null,
     room_name: 'geo-debate-debate-1',
     first_participant_slot: 1,
     current_turn_index: 0,
diff --git a/apps/web/app/space/[id]/(space)/debates/debates-page-client.test.tsx b/apps/web/app/space/[id]/(space)/debates/debates-page-client.test.tsx
index 6bf126f8a4..5f14273e19 100644
--- a/apps/web/app/space/[id]/(space)/debates/debates-page-client.test.tsx
+++ b/apps/web/app/space/[id]/(space)/debates/debates-page-client.test.tsx
@@ -48,7 +48,7 @@ vi.mock('~/core/debates/hooks', () => ({
   useDebateMediaArtifactUrl: () => ({ mutate: mocks.mediaArtifactMutate }),
   useDebateTranscript: () => ({ data: { segments: [] }, isLoading: false, error: null }),
   useDebateClaims: () => ({ data: { claims: [] } }),
-  useJoinDebateQueue: () => ({ mutate: vi.fn(), isPending: false }),
+  useJoinDebateQueue: () => ({ mutateAsync: vi.fn(), isPending: false }),
 }));
 
 vi.mock('~/core/hooks/use-space', () => ({
@@ -138,6 +138,7 @@ function completedDebate(): Debate {
       description: null,
     },
     status: 'complete',
+    response_kind: null,
     room_name: 'debate-1',
     first_participant_slot: 1,
     current_turn_index: 1,
diff --git a/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.test.tsx b/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.test.tsx
index 0f59b1eaf4..60e691b0a2 100644
--- a/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.test.tsx
+++ b/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.test.tsx
@@ -17,6 +17,8 @@ const mocks = vi.hoisted(() => ({
   mutate: vi.fn(),
   acceptMutate: vi.fn(),
   rejectMutate: vi.fn(),
+  submitResponse: vi.fn(),
+  optimisticResponses: new Map<string, 'positive' | 'negative' | null>(),
 }));
 
 vi.mock('next/navigation', () => ({
@@ -36,7 +38,6 @@ vi.mock('~/core/debates/hooks', () => ({
     error: null,
   }),
   useDebate: () => ({ data: { claim: { claim_entity_id: 'claim-source' } } }),
-  useUpdateDebateRematchPosition: () => mutation(),
   useCreateDebateRematchRequest: () => mutation(),
   useLeaveDebateRematch: () => mutation(),
   useAcceptDebateRematchRequest: () => mutation(mocks.acceptMutate),
@@ -64,6 +65,14 @@ vi.mock('~/core/sync/use-store', () => ({
   }),
 }));
 
+vi.mock('~/core/hooks/use-entity-vote', () => ({
+  useEntityResponse: ({ entityId }: { entityId: string }) => ({
+    submitResponse: (direction: 'positive' | 'negative' | 'clear') => mocks.submitResponse(entityId, direction),
+    optimisticResponse: mocks.optimisticResponses.get(entityId),
+    isConnected: true,
+  }),
+}));
+
 function mutation(mutate = mocks.mutate) {
   return { mutate, mutateAsync: mutate, isPending: false, error: null };
 }
@@ -73,6 +82,8 @@ beforeEach(() => {
   mocks.mutate.mockReset();
   mocks.acceptMutate.mockReset();
   mocks.rejectMutate.mockReset();
+  mocks.submitResponse.mockReset();
+  mocks.optimisticResponses.clear();
   mocks.session = session();
   mocks.claims = [sharedClaim()];
   document.body.style.overflow = '';
@@ -120,17 +131,63 @@ describe('DebateRematchPageClient', () => {
     expect(screen.getAllByRole('button', { name: 'Request debate' })[0]).toBeEnabled();
   });
 
-  it('shows each side its holder avatar in the claim position controls', () => {
+  it('renders active semantic response buttons with holder avatars', () => {
     render(<DebateRematchPageClient sessionId="rematch-1" />);
 
     const sharedClaimCard = screen.getByRole('heading', { name: 'A claim both participants chose' }).closest('article');
     expect(sharedClaimCard).not.toBeNull();
-    // Local picked Yes and the opponent picked No, so each pill carries one avatar.
-    expect(within(sharedClaimCard!).getByRole('button', { name: 'Yes' }).querySelector('img, svg')).not.toBeNull();
-    expect(within(sharedClaimCard!).getByRole('button', { name: 'No' }).querySelector('img, svg')).not.toBeNull();
+    expect(within(sharedClaimCard!).getByRole('button', { name: 'Agree' })).toBeEnabled();
+    expect(within(sharedClaimCard!).getByRole('button', { name: 'Disagree' })).toBeEnabled();
+    expect(within(sharedClaimCard!).getByRole('button', { name: 'Agree' }).querySelector('img, svg')).not.toBeNull();
+    expect(within(sharedClaimCard!).getByRole('button', { name: 'Disagree' }).querySelector('img, svg')).not.toBeNull();
+  });
+
+  it('changes responses through the semantic buttons without rendering a second response area', () => {
+    mocks.claims = [
+      {
+        ...sharedClaim(),
+        participants: [
+          { user_id: 'user-local', position: true, position_label: 'Agree' },
+          { user_id: 'user-remote', position: true, position_label: 'Agree' },
+        ],
+      },
+    ];
+
+    render(<DebateRematchPageClient sessionId="rematch-1" />);
+
+    const sharedClaimCard = screen.getByRole('heading', { name: 'A claim both participants chose' }).closest('article');
+    expect(sharedClaimCard).not.toBeNull();
+    fireEvent.click(within(sharedClaimCard!).getByRole('button', { name: 'Disagree' }));
+    expect(mocks.submitResponse).toHaveBeenCalledWith('claim-shared', 'negative');
+    expect(screen.queryByText('You both have the same response. Change yours to request this debate.')).toBeNull();
+    const syntheticClaimCard = screen.getByRole('heading', { name: 'A newly published claim' }).closest('article');
+    expect(syntheticClaimCard).not.toBeNull();
+    expect(within(syntheticClaimCard!).queryByText('Respond before requesting')).toBeNull();
+    expect(within(syntheticClaimCard!).getByRole('button', { name: 'Agree' })).toBeEnabled();
+    expect(within(syntheticClaimCard!).getByRole('button', { name: 'Disagree' })).toBeEnabled();
+  });
+
+  it('uses Verify and Dispute for factual claims', () => {
+    mocks.claims = [
+      {
+        ...sharedClaim(),
+        response_kind: 'veracity',
+        participants: [
+          { user_id: 'user-local', position: true, position_label: 'Verify' },
+          { user_id: 'user-remote', position: false, position_label: 'Dispute' },
+        ],
+      },
+    ];
+
+    render(<DebateRematchPageClient sessionId="rematch-1" />);
+
+    const claimCard = screen.getByRole('heading', { name: 'A claim both participants chose' }).closest('article');
+    expect(claimCard).not.toBeNull();
+    expect(within(claimCard!).getByRole('button', { name: 'Verify' })).toBeEnabled();
+    expect(within(claimCard!).getByRole('button', { name: 'Dispute' })).toBeEnabled();
   });
 
-  it('shows an incoming request in the shared dialog and preserves rematch actions', () => {
+  it('shows authoritative stance labels in the incoming request dialog and preserves rematch actions', () => {
     mocks.session = session({
       status: 'request_pending',
       request: {
@@ -140,7 +197,10 @@ describe('DebateRematchPageClient', () => {
         requester_user_id: 'user-remote',
         recipient_user_id: 'user-local',
         requester_position: false,
+        requester_position_label: 'Disagree',
         recipient_position: true,
+        recipient_position_label: 'Agree',
+        response_kind: 'stance',
         turn_format_id: 'standard',
         created_at: '2026-07-10T10:00:00.000Z',
         expires_at: '2026-07-10T10:02:00.000Z',
@@ -154,8 +214,8 @@ describe('DebateRematchPageClient', () => {
     expect(within(dialog).getByText('You')).toBeInTheDocument();
     expect(within(dialog).getByText('Salina')).toBeInTheDocument();
     expect(within(dialog).getByText('VS')).toBeInTheDocument();
-    expect(within(within(dialog).getByText('You').parentElement!).getByText('Yes')).toBeInTheDocument();
-    expect(within(within(dialog).getByText('Salina').parentElement!).getByText('No')).toBeInTheDocument();
+    expect(within(within(dialog).getByText('You').parentElement!).getByText('Agree')).toBeInTheDocument();
+    expect(within(within(dialog).getByText('Salina').parentElement!).getByText('Disagree')).toBeInTheDocument();
     expect(within(dialog).getAllByText('1m')).toHaveLength(2);
     expect(within(dialog).getAllByText('45s')).toHaveLength(2);
     expect(document.body.style.overflow).toBe('hidden');
@@ -173,7 +233,31 @@ describe('DebateRematchPageClient', () => {
     expect(document.documentElement.style.overflow).toBe('');
   });
 
-  it('disables every claim card while a rematch request is pending', () => {
+  it('falls back to Agree and Disagree for incoming requests without response metadata', () => {
+    mocks.session = session({
+      status: 'request_pending',
+      request: {
+        id: 'request-legacy',
+        status: 'pending',
+        claim: claimSummary('claim-shared', 'A claim both participants chose'),
+        requester_user_id: 'user-remote',
+        recipient_user_id: 'user-local',
+        requester_position: false,
+        recipient_position: true,
+        turn_format_id: 'standard',
+        created_at: '2026-07-10T10:00:00.000Z',
+        expires_at: '2026-07-10T10:02:00.000Z',
+      },
+    });
+
+    render(<DebateRematchPageClient sessionId="rematch-1" />);
+
+    const dialog = screen.getByRole('dialog', { name: 'A claim both participants chose' });
+    expect(within(within(dialog).getByText('You').parentElement!).getByText('Agree')).toBeInTheDocument();
+    expect(within(within(dialog).getByText('Salina').parentElement!).getByText('Disagree')).toBeInTheDocument();
+  });
+
+  it('disables debate requests while a rematch request is pending', () => {
     mocks.session = session({
       status: 'request_pending',
       request: {
@@ -183,7 +267,10 @@ describe('DebateRematchPageClient', () => {
         requester_user_id: 'user-local',
         recipient_user_id: 'user-remote',
         requester_position: true,
+        requester_position_label: 'Agree',
         recipient_position: false,
+        recipient_position_label: 'Disagree',
+        response_kind: 'stance',
         turn_format_id: 'standard',
         created_at: '2026-07-10T10:00:00.000Z',
         expires_at: '2026-07-10T10:02:00.000Z',
@@ -193,9 +280,34 @@ describe('DebateRematchPageClient', () => {
     render(<DebateRematchPageClient sessionId="rematch-1" />);
 
     expect(screen.getByRole('button', { name: 'Requesting...' })).toBeDisabled();
-    expect(screen.getAllByRole('button', { name: /^(Yes|No)$/ }).every(button => button.hasAttribute('disabled'))).toBe(
-      true
-    );
+    expect(screen.getAllByRole('button', { name: /^(Agree|Disagree)$/ })).toHaveLength(4);
+  });
+
+  it('explains when response changes cancel a rematch request', () => {
+    mocks.session = session({
+      request: {
+        id: 'request-1',
+        status: 'expired',
+        claim: claimSummary('claim-shared', 'A claim both participants chose'),
+        requester_user_id: 'user-local',
+        recipient_user_id: 'user-remote',
+        requester_position: true,
+        requester_position_label: 'Agree',
+        recipient_position: false,
+        recipient_position_label: 'Disagree',
+        response_kind: 'stance',
+        cancellation_reason: 'claim_response_position_changed',
+        turn_format_id: 'standard',
+        created_at: '2026-07-10T10:00:00.000Z',
+        expires_at: '2026-07-10T10:02:00.000Z',
+      },
+    });
+
+    render(<DebateRematchPageClient sessionId="rematch-1" />);
+
+    expect(
+      screen.getByText('This request was cancelled because the responses no longer oppose each other.')
+    ).toBeInTheDocument();
   });
 
   it('filters to opponent-committed claims on the Debate now tab', () => {
@@ -217,7 +329,7 @@ describe('DebateRematchPageClient', () => {
 
     fireEvent.click(screen.getByRole('button', { name: /Debate now/ }));
 
-    expect(screen.getByText(/Salina hasn't picked a side yet/)).toBeInTheDocument();
+    expect(screen.getByText(/Salina hasn't responded yet/)).toBeInTheDocument();
   });
 
   it('narrows the list to the selected topic', () => {
@@ -278,9 +390,10 @@ function session(overrides: Partial<DebateRematchSession> = {}): DebateRematchSe
 function sharedClaim(): DebateRematchClaim {
   return {
     claim: claimSummary('claim-shared', 'A claim both participants chose'),
+    response_kind: 'stance',
     participants: [
-      { user_id: 'user-local', position: true },
-      { user_id: 'user-remote', position: false },
+      { user_id: 'user-local', position: true, position_label: 'Agree' },
+      { user_id: 'user-remote', position: false, position_label: 'Disagree' },
     ],
     shared_preference: true,
     recently_rejected: false,
diff --git a/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.tsx b/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.tsx
index 8df38d75bf..8c04079b73 100644
--- a/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.tsx
+++ b/apps/web/app/space/[id]/(space)/debates/rematches/[sessionId]/rematch-page-client.tsx
@@ -7,7 +7,7 @@ import * as React from 'react';
 import cx from 'classnames';
 import { useRouter } from 'next/navigation';
 
-import { CLAIM_TYPE_ID, TOPICS_PROPERTY_ID } from '~/core/claims/ontology';
+import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID, TOPICS_PROPERTY_ID } from '~/core/claims/ontology';
 import {
   type DebateRematchClaim,
   type DebateRematchParticipant,
@@ -24,12 +24,15 @@ import {
   useDebateRematchClaims,
   useLeaveDebateRematch,
   useRejectDebateRematchRequest,
-  useUpdateDebateRematchPosition,
 } from '~/core/debates/hooks';
+import { useEntityResponse } from '~/core/hooks/use-entity-vote';
+import { uuidToHex } from '~/core/id/normalize';
+import { responsePositionLabel } from '~/core/responses/entity-response';
 import { useQueryEntities } from '~/core/sync/use-store';
 
 import { Avatar } from '~/design-system/avatar';
 import { Button } from '~/design-system/button';
+import { getChecked } from '~/design-system/checkbox';
 import { ChevronDownSmall } from '~/design-system/icons/chevron-down-small';
 import { Text } from '~/design-system/text';
 
@@ -63,7 +66,6 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
   const publishedClaimIds = React.useMemo(() => publishedClaims.map(claim => claim.id), [publishedClaims]);
   const savedClaimsQuery = useDebateRematchClaims(sessionId);
   const publishedClaimsQuery = useDebateRematchClaims(sessionId, publishedClaimIds);
-  const updatePosition = useUpdateDebateRematchPosition(sessionId);
   const createRequest = useCreateDebateRematchRequest(sessionId);
   const leaveSession = useLeaveDebateRematch(sessionId);
   const acceptRequest = useAcceptDebateRematchRequest();
@@ -98,9 +100,11 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
             claim: claim.name!,
             description: claim.description,
           },
+          response_kind: claimResponseKind(claim, claim.spaces[0]!),
           participants: (session?.participants ?? []).map(participant => ({
             user_id: participant.user_id,
             position: null,
+            position_label: null,
           })),
           shared_preference: false,
           recently_rejected: false,
@@ -149,7 +153,7 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
   const [tab, setTab] = React.useState<'all' | 'debate-now'>('all');
   const [topicFilter, setTopicFilter] = React.useState<string>('');
 
-  // "Debate now" = claims the opponent has taken a position on; the tab badge counts them.
+  // "Debate now" = claims the opponent has responded to; the tab badge counts them.
   const opponentPositionCount = React.useMemo(
     () => claims.filter(claim => opponentPositionOf(claim) !== null).length,
     [claims, opponentPositionOf]
@@ -194,15 +198,16 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
   const incomingRequestParticipants =
     incomingRequest && session
       ? session.participants.map(participant => {
-          const position =
-            participant.user_id === incomingRequest.requester_user_id
-              ? incomingRequest.requester_position
-              : incomingRequest.recipient_position;
+          const requester = participant.user_id === incomingRequest.requester_user_id;
+          const position = requester ? incomingRequest.requester_position : incomingRequest.recipient_position;
+          const positionLabel = requester
+            ? incomingRequest.requester_position_label
+            : incomingRequest.recipient_position_label;
 
           return {
             ...participant,
             position,
-            position_label: position ? 'Yes' : 'No',
+            position_label: positionLabel ?? responsePositionLabel(incomingRequest.response_kind ?? null, position),
           };
         })
       : [];
@@ -259,17 +264,18 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
                 : publishedClaimsQuery.error?.message}
           </Text>
         )}
-        {(updatePosition.error instanceof Error ||
-          createRequest.error instanceof Error ||
-          leaveSession.error instanceof Error) && (
+        {(createRequest.error instanceof Error || leaveSession.error instanceof Error) && (
           <Text color="red-01" className="mb-4">
-            {updatePosition.error instanceof Error
-              ? updatePosition.error.message
-              : createRequest.error instanceof Error
-                ? createRequest.error.message
-                : leaveSession.error instanceof Error
-                  ? leaveSession.error.message
-                  : null}
+            {createRequest.error instanceof Error
+              ? createRequest.error.message
+              : leaveSession.error instanceof Error
+                ? leaveSession.error.message
+                : null}
+          </Text>
+        )}
+        {session?.request?.status === 'expired' && session.request.cancellation_reason && (
+          <Text color="red-01" className="mb-4">
+            {rematchCancellationMessage(session.request.cancellation_reason)}
           </Text>
         )}
 
@@ -281,13 +287,6 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
               topic={topicsByClaimId.get(claim.claim.claim_entity_id)?.[0] ?? null}
               session={session}
               currentUserId={currentUserId}
-              onPositionChange={position =>
-                updatePosition.mutate({
-                  claimId: claim.claim.claim_entity_id,
-                  position,
-                  sourceSpaceId: claim.claim.space_id,
-                })
-              }
               onRequest={() =>
                 createRequest.mutate({
                   source_space_id: claim.claim.space_id,
@@ -295,7 +294,7 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
                   format_id: defaultDebateFormatId,
                 })
               }
-              busy={updatePosition.isPending || createRequest.isPending || session?.status === 'request_pending'}
+              busy={createRequest.isPending || session?.status === 'request_pending'}
             />
           ))}
         </div>
@@ -304,7 +303,7 @@ export function DebateRematchPageClient({ sessionId }: { sessionId: string }) {
           <div className="rounded-lg border border-grey-02 bg-white p-6 text-center">
             <Text color="grey-04">
               {tab === 'debate-now'
-                ? `${remoteName} hasn't picked a side yet. When they do, those claims show up here.`
+                ? `${remoteName} hasn't responded yet. When they do, those claims show up here.`
                 : topicFilter
                   ? 'No claims match this topic.'
                   : 'No other eligible claims are available yet.'}
@@ -354,7 +353,6 @@ function RematchClaimCard({
   topic,
   session,
   currentUserId,
-  onPositionChange,
   onRequest,
   busy,
 }: {
@@ -362,13 +360,23 @@ function RematchClaimCard({
   topic: string | null;
   session: DebateRematchSession | null;
   currentUserId: string | null;
-  onPositionChange: (position: boolean) => void;
   onRequest: () => void;
   busy: boolean;
 }) {
-  const localPosition = claim.participants.find(position => position.user_id === currentUserId)?.position ?? null;
-  const remotePosition = claim.participants.find(position => position.user_id !== currentUserId)?.position ?? null;
+  const localResponse = claim.participants.find(position => position.user_id === currentUserId) ?? null;
+  const remoteResponse = claim.participants.find(position => position.user_id !== currentUserId) ?? null;
+  const localPosition = localResponse?.position ?? null;
+  const remotePosition = remoteResponse?.position ?? null;
   const opposing = localPosition !== null && remotePosition !== null && localPosition !== remotePosition;
+  const { submitResponse, optimisticResponse, isConnected } = useEntityResponse({
+    entityId: claim.claim.claim_entity_id,
+    spaceId: claim.claim.space_id,
+    responseKind: claim.response_kind,
+  });
+  let displayedLocalPosition = localPosition;
+  if (optimisticResponse !== undefined) {
+    displayedLocalPosition = optimisticResponse === null ? null : optimisticResponse === 'positive';
+  }
   const request = session?.request;
   const requesting =
     session?.status === 'request_pending' && request?.claim.claim_entity_id === claim.claim.claim_entity_id;
@@ -377,7 +385,7 @@ function RematchClaimCard({
     <article className="rounded-lg border border-grey-02 bg-white p-5">
       <div className="flex items-start justify-between gap-3">
         <Text as="div" variant="footnote" color="grey-04">
-          {topic ?? (claim.shared_preference ? 'You both picked a side' : 'More claims')}
+          {topic ?? (claim.shared_preference ? 'You both responded' : 'More claims')}
         </Text>
         {claim.recently_rejected && (
           <Text as="div" variant="footnote" color="grey-04">
@@ -391,23 +399,29 @@ function RematchClaimCard({
 
       <div className="mt-5 grid grid-cols-2 gap-2">
         {[true, false].map(position => {
-          const localOnPosition = localPosition === position;
-          const holders = session
-            ? claim.participants
-                .filter(participant => participant.position === position)
-                .map(participant => session.participants.find(sp => sp.user_id === participant.user_id))
-                .filter((participant): participant is DebateRematchParticipant => Boolean(participant))
-            : [];
+          const positionLabel = responsePositionLabel(claim.response_kind, position);
+          const holderIds = new Set(
+            claim.participants
+              .filter(participant => participant.user_id !== currentUserId && participant.position === position)
+              .map(participant => participant.user_id)
+          );
+          if (currentUserId && displayedLocalPosition === position) holderIds.add(currentUserId);
+          const holders = session?.participants.filter(participant => holderIds.has(participant.user_id)) ?? [];
+          const selected = displayedLocalPosition === position;
           return (
             <button
-              key={String(position)}
               type="button"
-              aria-pressed={localOnPosition}
-              onClick={() => onPositionChange(position)}
-              disabled={busy || requesting}
-              className="flex min-h-9 items-center justify-between gap-2 rounded-full bg-bg px-3 text-button text-text transition-colors hover:bg-grey-01 disabled:opacity-60 aria-pressed:bg-green"
+              key={String(position)}
+              aria-pressed={selected}
+              disabled={!claim.response_kind || !isConnected}
+              onClick={() => submitResponse(selected ? 'clear' : position ? 'positive' : 'negative')}
+              className={cx(
+                'flex min-h-9 items-center justify-between gap-2 rounded-full px-3 text-button transition-colors',
+                selected ? 'bg-text text-white' : 'bg-bg text-text hover:bg-grey-01',
+                (!claim.response_kind || !isConnected) && 'cursor-default opacity-50'
+              )}
             >
-              <span>{position ? 'Yes' : 'No'}</span>
+              <span>{positionLabel}</span>
               {holders.length > 0 && <PositionAvatars participants={holders} />}
             </button>
           );
@@ -428,6 +442,37 @@ function RematchClaimCard({
   );
 }
 
+function claimResponseKind(
+  entity: { values?: Array<{ isDeleted?: boolean; property: { id: string }; spaceId: string; value: string }> },
+  spaceId: string
+): 'stance' | 'veracity' {
+  const isFactual =
+    getChecked(
+      entity.values?.find(
+        value =>
+          value.isDeleted !== true &&
+          uuidToHex(value.spaceId) === uuidToHex(spaceId) &&
+          uuidToHex(value.property.id) === uuidToHex(CLAIM_IS_FACTUAL_PROPERTY_ID)
+      )?.value
+    ) === true;
+  return isFactual ? 'veracity' : 'stance';
+}
+
+function rematchCancellationMessage(reason: string) {
+  switch (reason) {
+    case 'claim_response_withdrawn':
+      return 'This request was cancelled because a participant withdrew their response.';
+    case 'claim_response_kind_changed':
+      return 'This request was cancelled because the claim’s response type changed.';
+    case 'claim_response_position_changed':
+    case 'claim_responses_not_opposed':
+    case 'claim_response_changed_during_accept':
+      return 'This request was cancelled because the responses no longer oppose each other.';
+    default:
+      return 'This debate request is no longer available.';
+  }
+}
+
 function PositionAvatars({ participants }: { participants: DebateRematchParticipant[] }) {
   return (
     <span className="flex -space-x-1.5">
diff --git a/apps/web/app/space/[id]/(space)/debug-debates/debug-debates-page-client.test.tsx b/apps/web/app/space/[id]/(space)/debug-debates/debug-debates-page-client.test.tsx
index 7a7f549335..55c4509405 100644
--- a/apps/web/app/space/[id]/(space)/debug-debates/debug-debates-page-client.test.tsx
+++ b/apps/web/app/space/[id]/(space)/debug-debates/debug-debates-page-client.test.tsx
@@ -414,6 +414,7 @@ function debate(id: string, createdAt = '2026-07-02T00:00:00.000Z'): Debate {
       description: null,
     },
     status: 'complete',
+    response_kind: null,
     room_name: id,
     first_participant_slot: 1,
     current_turn_index: 1,
diff --git a/apps/web/codegen.ts b/apps/web/codegen.ts
index 5a9e4237d9..518628631a 100644
--- a/apps/web/codegen.ts
+++ b/apps/web/codegen.ts
@@ -9,6 +9,12 @@ const config: CodegenConfig = {
   generates: {
     './core/gql/': {
       preset: 'client',
+      config: {
+        // Preserve the runtime enum values and permissive custom-scalar shape
+        // used by existing consumers while adopting the v6 operation-only output.
+        enumType: 'native',
+        defaultScalarType: 'any',
+      },
     },
   },
 };
diff --git a/apps/web/core/debates/api.test.ts b/apps/web/core/debates/api.test.ts
index 606119356c..498c415762 100644
--- a/apps/web/core/debates/api.test.ts
+++ b/apps/web/core/debates/api.test.ts
@@ -6,6 +6,9 @@ import {
   endDebateTurn,
   getDebateActivity,
   getGeoChatSession,
+  joinDebateQueue,
+  listDebateClaims,
+  notifyClaimResponseIndexed,
   resetGeoChatSession,
   retryDebatePhaseBoundaryRequest,
   updateDebateAvailability,
@@ -160,6 +163,125 @@ describe('debate availability', () => {
   });
 });
 
+describe('debate queue readiness', () => {
+  it('joins with a bodyless POST and no JSON content type', async () => {
+    const response = { claim: { id: 'claim-1' }, match: null };
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify(response), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    );
+    vi.stubGlobal('fetch', fetch);
+
+    await expect(joinDebateQueue('space-1', 'claim-1', vi.fn(), 'user-a')).resolves.toEqual(response);
+
+    expect(fetch).toHaveBeenCalledWith('http://localhost:8080/spaces/space-1/claims/claim-1/debate-queue', {
+      method: 'POST',
+      headers: { Authorization: 'Bearer access-token' },
+      body: undefined,
+      signal: undefined,
+    });
+  });
+});
+
+describe('debate claim hydration authentication', () => {
+  it('does not silently downgrade a signed-in claim request to anonymous access', async () => {
+    resetGeoChatSession();
+    window.localStorage.removeItem('geo:chat-session');
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ claims: [] }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    );
+    vi.stubGlobal('fetch', fetch);
+    const getPrivyIdentityToken = vi.fn().mockRejectedValue(new Error('Identity token unavailable'));
+
+    await expect(listDebateClaims('space-1', ['claim-1'], getPrivyIdentityToken, 'user-a')).rejects.toThrow(
+      'Identity token unavailable'
+    );
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('keeps anonymous claim browsing available without an authorization header', async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ claims: [] }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    );
+    vi.stubGlobal('fetch', fetch);
+
+    await expect(listDebateClaims('space-1', ['claim-1'])).resolves.toEqual({ claims: [] });
+    expect(fetch).toHaveBeenCalledWith(
+      'http://localhost:8080/spaces/space-1/debate-claims?claim_ids=claim-1',
+      expect.objectContaining({ headers: {} })
+    );
+  });
+});
+
+describe('claim response indexing notifications', () => {
+  it('posts the indexed response snapshot and accepts an empty success response', async () => {
+    const fetch = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    vi.stubGlobal('fetch', fetch);
+
+    await expect(
+      notifyClaimResponseIndexed('space-1', 'claim-1', 'veracity', false, vi.fn(), 'user-a')
+    ).resolves.toBeUndefined();
+
+    expect(fetch).toHaveBeenCalledWith('http://localhost:8080/spaces/space-1/claims/claim-1/response-indexed', {
+      method: 'POST',
+      headers: {
+        Authorization: 'Bearer access-token',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ response_kind: 'veracity', position: false }),
+      signal: undefined,
+    });
+  });
+
+  it('retries transient failures twice before succeeding', async () => {
+    vi.useFakeTimers();
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce(new Response(null, { status: 503, statusText: 'Unavailable' }))
+      .mockResolvedValueOnce(new Response(null, { status: 503, statusText: 'Unavailable' }))
+      .mockResolvedValueOnce(new Response(null, { status: 204 }));
+    vi.stubGlobal('fetch', fetch);
+
+    const notification = notifyClaimResponseIndexed('space-1', 'claim-1', 'stance', null, vi.fn(), 'user-a');
+    await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(1));
+    await vi.runAllTimersAsync();
+
+    await expect(notification).resolves.toBeUndefined();
+    expect(fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('stops retrying when the notification is cancelled', async () => {
+    vi.useFakeTimers();
+    const fetch = vi.fn().mockResolvedValue(new Response(null, { status: 503, statusText: 'Unavailable' }));
+    vi.stubGlobal('fetch', fetch);
+    const controller = new AbortController();
+
+    const notification = notifyClaimResponseIndexed(
+      'space-1',
+      'claim-1',
+      'stance',
+      true,
+      vi.fn(),
+      'user-a',
+      controller.signal
+    );
+    await vi.waitFor(() => expect(fetch).toHaveBeenCalledOnce());
+    controller.abort();
+
+    await expect(notification).rejects.toMatchObject({ name: 'AbortError' });
+    await vi.runAllTimersAsync();
+    expect(fetch).toHaveBeenCalledOnce();
+  });
+});
+
 describe('turn yields', () => {
   it('posts the client cutoff to the addressed turn', async () => {
     const debate = { id: 'debate-1', status: 'in_progress', turn_yields: [] };
diff --git a/apps/web/core/debates/api.ts b/apps/web/core/debates/api.ts
index 30551cb2ad..48cd76bd2b 100644
--- a/apps/web/core/debates/api.ts
+++ b/apps/web/core/debates/api.ts
@@ -6,6 +6,7 @@ export type DebateStatus = 'ready' | 'connecting' | 'preflight' | 'in_progress'
 export type DebateRecordingSource = 'local';
 export type DebateRematchStatus = 'deciding' | 'browsing' | 'request_pending' | 'converted' | 'ended' | 'expired';
 export type DebateRematchRequestStatus = 'pending' | 'accepted' | 'rejected' | 'expired';
+export type DebateResponseKind = 'stance' | 'veracity';
 
 export type DebateParticipantSummary = {
   user_id: string;
@@ -25,6 +26,8 @@ export type DebateClaimSummary = {
 export type DebateMatch = {
   id: string;
   status: DebateMatchStatus;
+  response_kind: DebateResponseKind | null;
+  cancellation_reason?: string | null;
   claim: DebateClaimSummary;
   participants: DebateMatchParticipant[];
   turn_format_id: string | null;
@@ -175,6 +178,7 @@ export type Debate = {
   id: string;
   claim: DebateClaimSummary;
   status: DebateStatus;
+  response_kind: DebateResponseKind | null;
   room_name: string;
   first_participant_slot: ParticipantSlot;
   current_turn_index: number;
@@ -251,7 +255,11 @@ export type DebateRematchRequest = {
   requester_user_id: string;
   recipient_user_id: string;
   requester_position: boolean;
+  requester_position_label?: string | null;
   recipient_position: boolean;
+  recipient_position_label?: string | null;
+  response_kind?: DebateResponseKind | null;
+  cancellation_reason?: string | null;
   turn_format_id: string;
   created_at: string;
   expires_at: string;
@@ -276,10 +284,12 @@ export type DebateRematchSession = {
 export type DebateRematchClaimPosition = {
   user_id: string;
   position: boolean | null;
+  position_label: string | null;
 };
 
 export type DebateRematchClaim = {
   claim: DebateClaimSummary;
+  response_kind: DebateResponseKind | null;
   participants: DebateRematchClaimPosition[];
   shared_preference: boolean;
   recently_rejected: boolean;
@@ -322,7 +332,11 @@ export type DebateClaim = {
   claim_entity_id: string;
   claim: string;
   description: string | null;
-  viewer_waiting_position: boolean | null;
+  response_kind: DebateResponseKind;
+  viewer_response: { position: boolean; position_label: string } | null;
+  viewer_debate_ready: boolean;
+  readiness_disabled_reason: string | null;
+  readiness_changed_at: string | null;
   online_choices: DebateOnlineChoice[];
   active_match: DebateMatch | null;
   active_debate: Debate | null;
@@ -341,10 +355,6 @@ export type DebateClaimsResponse = {
   claims: DebateClaim[];
 };
 
-export type JoinDebateQueueRequest = {
-  position: boolean;
-};
-
 export type JoinDebateQueueResponse = {
   claim: DebateClaim;
   match: DebateMatch | null;
@@ -497,7 +507,7 @@ export async function listDebateClaims(
 ) {
   const query = claimIds.length > 0 ? `?claim_ids=${encodeURIComponent(claimIds.join(','))}` : '';
   return geoChatRequest<DebateClaimsResponse>(`/spaces/${spaceId}/debate-claims${query}`, {
-    auth: 'optional',
+    auth: accountKey ? true : 'optional',
     getPrivyIdentityToken,
     accountKey,
     signal,
@@ -507,13 +517,11 @@ export async function listDebateClaims(
 export async function joinDebateQueue(
   spaceId: string,
   claimId: string,
-  request: JoinDebateQueueRequest,
   getPrivyIdentityToken: GetPrivyIdentityToken,
   accountKey: string | null
 ) {
   return geoChatRequest<JoinDebateQueueResponse>(`/spaces/${spaceId}/claims/${claimId}/debate-queue`, {
     method: 'POST',
-    body: request,
     auth: true,
     getPrivyIdentityToken,
     accountKey,
@@ -534,20 +542,33 @@ export async function leaveDebateQueue(
   });
 }
 
-export async function updateDebatePreference(
+export async function notifyClaimResponseIndexed(
   spaceId: string,
   claimId: string,
-  request: JoinDebateQueueRequest,
+  responseKind: DebateResponseKind,
+  position: boolean | null,
   getPrivyIdentityToken: GetPrivyIdentityToken,
-  accountKey: string | null
+  accountKey: string | null,
+  signal?: AbortSignal
 ) {
-  return geoChatRequest<JoinDebateQueueResponse>(`/spaces/${spaceId}/claims/${claimId}/debate-preference`, {
-    method: 'PUT',
-    body: request,
-    auth: true,
-    getPrivyIdentityToken,
-    accountKey,
-  });
+  const request = () =>
+    geoChatRequest<void>(`/spaces/${spaceId}/claims/${claimId}/response-indexed`, {
+      method: 'POST',
+      body: { response_kind: responseKind, position },
+      auth: true,
+      getPrivyIdentityToken,
+      accountKey,
+      signal,
+    });
+
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await request();
+    } catch (error) {
+      if (attempt >= 2 || !isTransientResponseNotificationError(error)) throw error;
+      await waitForResponseNotificationRetry(250 * 2 ** attempt, signal);
+    }
+  }
 }
 
 export async function acceptDebateMatch(
@@ -743,23 +764,6 @@ export async function listDebateRematchClaims(
   });
 }
 
-export async function updateDebateRematchPosition(
-  sessionId: string,
-  claimId: string,
-  position: boolean,
-  sourceSpaceId: string,
-  getPrivyIdentityToken: GetPrivyIdentityToken,
-  accountKey: string | null
-) {
-  return geoChatRequest<DebateRematchClaimsResponse>(`/debate-rematches/${sessionId}/claims/${claimId}/position`, {
-    method: 'PUT',
-    body: { position, source_space_id: sourceSpaceId },
-    auth: true,
-    getPrivyIdentityToken,
-    accountKey,
-  });
-}
-
 export async function createDebateRematchRequest(
   sessionId: string,
   request: { source_space_id: string; claim_id: string; format_id: string },
@@ -999,6 +1003,8 @@ async function geoChatRequest<T>(path: string, options: RequestOptions = {}): Pr
     throw await requestError(response);
   }
 
+  if (response.status === 204) return undefined as T;
+
   return response.json() as Promise<T>;
 }
 
@@ -1020,6 +1026,31 @@ const debatePhaseBoundaryRetryCodes = new Set([
   'recording_not_ready',
 ]);
 
+function isTransientResponseNotificationError(error: unknown) {
+  if (error instanceof GeoChatRequestError) {
+    return error.status === 429 || error.status >= 500;
+  }
+  return !(error instanceof DOMException && error.name === 'AbortError');
+}
+
+function waitForResponseNotificationRetry(delayMs: number, signal?: AbortSignal) {
+  if (signal?.aborted)
+    return Promise.reject(signal.reason ?? new DOMException('The operation was aborted', 'AbortError'));
+
+  return new Promise<void>((resolve, reject) => {
+    const finish = () => {
+      signal?.removeEventListener('abort', abort);
+      resolve();
+    };
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new DOMException('The operation was aborted', 'AbortError'));
+    };
+    const timer = setTimeout(finish, delayMs);
+    signal?.addEventListener('abort', abort, { once: true });
+  });
+}
+
 export async function retryDebatePhaseBoundaryRequest<T>(request: () => Promise<T>): Promise<T> {
   try {
     return await request();
diff --git a/apps/web/core/debates/browse/debate-feed.test.tsx b/apps/web/core/debates/browse/debate-feed.test.tsx
index 0497229e5f..7eb8ef6420 100644
--- a/apps/web/core/debates/browse/debate-feed.test.tsx
+++ b/apps/web/core/debates/browse/debate-feed.test.tsx
@@ -376,6 +376,7 @@ function completedDebate(id: string, claim: string, completedAt: string): Debate
       description: null,
     },
     status: 'complete',
+    response_kind: null,
     room_name: id,
     first_participant_slot: 1,
     current_turn_index: 1,
diff --git a/apps/web/core/debates/browse/join-debate-panel.test.tsx b/apps/web/core/debates/browse/join-debate-panel.test.tsx
new file mode 100644
index 0000000000..c4e3a26ef5
--- /dev/null
+++ b/apps/web/core/debates/browse/join-debate-panel.test.tsx
@@ -0,0 +1,116 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import '@testing-library/jest-dom/vitest';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { DebateClaim } from '../api';
+import { JoinDebatePanel } from './join-debate-panel';
+
+const mocks = vi.hoisted(() => ({
+  claims: [] as DebateClaim[],
+  joinMutate: vi.fn(),
+  leaveMutate: vi.fn(),
+  availabilityMutate: vi.fn(),
+}));
+
+vi.mock('~/core/debates/hooks', () => ({
+  useGeoChatAuth: () => ({ authenticated: true, accountKey: 'account-1' }),
+  useDebateClaims: () => ({ data: { claims: mocks.claims }, isLoading: false, error: null }),
+  useDebateActivity: () => ({ data: { available_to_debate: false }, isPending: false }),
+  useUpdateDebateAvailability: () => ({ mutate: mocks.availabilityMutate, isPending: false }),
+  useJoinDebateQueue: () => ({ mutateAsync: mocks.joinMutate, reset: vi.fn(), isPending: false, error: null }),
+  useLeaveDebateQueue: () => ({ mutateAsync: mocks.leaveMutate, isPending: false, error: null }),
+}));
+
+vi.mock('~/core/hooks/use-entity-vote', () => ({
+  useEntityResponseIndexingState: () => 'idle',
+  useEntityResponseIndexingSnapshot: () => ({ status: 'idle', pending: null, runId: null }),
+  useResetEntityResponseIndexingSnapshot: () => vi.fn(),
+}));
+
+vi.mock('~/core/sync/use-store', () => ({
+  useQueryEntities: () => ({ entities: [] }),
+}));
+
+vi.mock('~/partials/entity-page/entity-vote-buttons', () => ({
+  EntityVoteButtons: () => <div data-testid="entity-response-buttons">Entity response buttons</div>,
+}));
+
+beforeEach(() => {
+  mocks.claims = [];
+  vi.clearAllMocks();
+  mocks.joinMutate.mockReturnValue(new Promise(() => undefined));
+  mocks.leaveMutate.mockReturnValue(new Promise(() => undefined));
+});
+
+afterEach(cleanup);
+
+describe('JoinDebatePanel', () => {
+  it('prompts for a response with a disabled readiness switch', () => {
+    mocks.claims = [claim({ viewer_response: null })];
+
+    renderPanel();
+
+    expect(screen.getByTestId('entity-response-buttons')).toBeInTheDocument();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
+  });
+
+  it('renders backend labels and one bodyless join toggle after a response', () => {
+    mocks.claims = [
+      claim({
+        response_kind: 'veracity',
+        viewer_response: { position: false, position_label: 'Dispute' },
+        online_choices: [],
+      }),
+    ];
+
+    renderPanel();
+
+    expect(screen.queryByText('Ready to debate')).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    expect(mocks.joinMutate).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
+
+  it('leaves through the same readiness toggle', () => {
+    mocks.claims = [claim({ viewer_debate_ready: true })];
+
+    renderPanel();
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    expect(mocks.leaveMutate).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
+});
+
+function renderPanel() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(<JoinDebatePanel spaceId="space-1" onClose={vi.fn()} />, {
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  });
+}
+
+function claim(overrides: Partial<DebateClaim> = {}): DebateClaim {
+  return {
+    id: 'debate-claim-1',
+    space_id: 'space-1',
+    claim_entity_id: 'claim-1',
+    claim: 'Public transit should be free',
+    description: null,
+    response_kind: 'stance',
+    viewer_response: { position: true, position_label: 'Agree' },
+    viewer_debate_ready: false,
+    readiness_disabled_reason: null,
+    readiness_changed_at: null,
+    online_choices: [],
+    active_match: null,
+    active_debate: null,
+    created_at: '2026-08-06T00:00:00.000Z',
+    updated_at: '2026-08-06T00:00:00.000Z',
+    ...overrides,
+  };
+}
diff --git a/apps/web/core/debates/browse/join-debate-panel.tsx b/apps/web/core/debates/browse/join-debate-panel.tsx
index 7f4b7877d7..dc679a7b30 100644
--- a/apps/web/core/debates/browse/join-debate-panel.tsx
+++ b/apps/web/core/debates/browse/join-debate-panel.tsx
@@ -7,24 +7,18 @@ import * as React from 'react';
 import cx from 'classnames';
 
 import { TOPICS_PROPERTY_ID } from '~/core/claims/ontology';
-import type { DebateClaim, DebateOnlineChoice } from '~/core/debates/api';
-import {
-  useDebateActivity,
-  useDebateClaims,
-  useJoinDebateQueue,
-  useUpdateDebateAvailability,
-} from '~/core/debates/hooks';
+import type { DebateClaim } from '~/core/debates/api';
+import { ClaimDebateReadiness } from '~/core/debates/claim-debate-readiness';
+import { useDebateActivity, useDebateClaims, useUpdateDebateAvailability } from '~/core/debates/hooks';
 import { useQueryEntities } from '~/core/sync/use-store';
 import { validateEntityId } from '~/core/utils/utils';
 
-import { Avatar } from '~/design-system/avatar';
 import { Close } from '~/design-system/icons/close';
 import { Text } from '~/design-system/text';
 
 /**
  * "Join a debate" panel opened from the browse feed's Join debate button. Lists
- * the space's published claims with For/Against entry points into the debate
- * queue — the same mechanism the Claims tab uses.
+ * the space's published claims with their response-derived readiness controls.
  */
 export function JoinDebatePanel({ spaceId, onClose }: { spaceId: string; onClose: () => void }) {
   // geo-chat indexes the space's debatable claims, so ask it directly rather than
@@ -145,10 +139,7 @@ function JoinDebateCard({
   debateClaim: DebateClaim;
   topic: string | null;
 }) {
-  const joinQueue = useJoinDebateQueue(spaceId);
   const canJoin = !debateClaim.active_debate && !debateClaim.active_match;
-  const forChoice = debateClaim.online_choices.find(choice => choice.position === true);
-  const againstChoice = debateClaim.online_choices.find(choice => choice.position === false);
 
   return (
     <article className="rounded-lg border border-grey-02 bg-white p-5">
@@ -160,78 +151,13 @@ function JoinDebateCard({
       <Text as="h3" variant="smallTitle" color="text" className="block">
         {debateClaim.claim}
       </Text>
-      <div className="mt-3 grid grid-cols-2 gap-2">
-        <PositionButton
-          label={forChoice?.position_label ?? 'For'}
-          choice={forChoice}
-          position={true}
-          disabled={!canJoin || joinQueue.isPending || debateClaim.viewer_waiting_position === true}
-          selected={debateClaim.viewer_waiting_position === true}
-          onClick={() => joinQueue.mutate({ claimId: debateClaim.claim_entity_id, request: { position: true } })}
-        />
-        <PositionButton
-          label={againstChoice?.position_label ?? 'Against'}
-          choice={againstChoice}
-          position={false}
-          disabled={!canJoin || joinQueue.isPending || debateClaim.viewer_waiting_position === false}
-          selected={debateClaim.viewer_waiting_position === false}
-          onClick={() => joinQueue.mutate({ claimId: debateClaim.claim_entity_id, request: { position: false } })}
-        />
-      </div>
+      <ClaimDebateReadiness
+        debateClaim={debateClaim}
+        entityId={debateClaim.claim_entity_id}
+        spaceId={spaceId}
+        canEnable={canJoin}
+        className="mt-3"
+      />
     </article>
   );
 }
-
-function PositionButton({
-  label,
-  choice,
-  position,
-  disabled,
-  selected,
-  onClick,
-}: {
-  label: string;
-  choice: DebateOnlineChoice | undefined;
-  position: boolean;
-  disabled: boolean;
-  selected: boolean;
-  onClick: () => void;
-}) {
-  return (
-    <button
-      type="button"
-      aria-pressed={selected}
-      disabled={disabled}
-      onClick={onClick}
-      className={cx(
-        'flex min-h-7 items-center justify-between gap-2 rounded-full px-3 text-button text-text transition-colors disabled:opacity-60',
-        selected ? (position ? 'bg-green' : 'bg-red-01') : 'bg-bg hover:bg-grey-01'
-      )}
-    >
-      <span className="truncate">{label}</span>
-      {choice && choice.participant_count > 0 && <ChoiceAvatars choice={choice} />}
-    </button>
-  );
-}
-
-function ChoiceAvatars({ choice }: { choice: DebateOnlineChoice }) {
-  const participants = choice.participants.slice(0, 2);
-  const overflow = Math.max(0, choice.participant_count - participants.length);
-  return (
-    <span aria-hidden="true" className="flex shrink-0 items-center -space-x-2">
-      {participants.map(participant => (
-        <span
-          key={participant.user_id}
-          className="relative box-content block size-5 overflow-hidden rounded-full border-2 border-white"
-        >
-          <Avatar avatarUrl={participant.avatar_cid} value={participant.profile_space_id} size={20} />
-        </span>
-      ))}
-      {overflow > 0 && (
-        <span className="relative box-content flex h-5 min-w-5 items-center justify-center rounded-full border-2 border-white bg-grey-02 px-1 text-[11px] leading-5 text-grey-04 tabular-nums">
-          +{overflow}
-        </span>
-      )}
-    </span>
-  );
-}
diff --git a/apps/web/core/debates/claim-debate-button.test.tsx b/apps/web/core/debates/claim-debate-button.test.tsx
index 7bbc39f5ae..3e4190c139 100644
--- a/apps/web/core/debates/claim-debate-button.test.tsx
+++ b/apps/web/core/debates/claim-debate-button.test.tsx
@@ -1,6 +1,9 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import '@testing-library/jest-dom/vitest';
 import { cleanup, fireEvent, render, screen } from '@testing-library/react';
 
+import type { ReactElement } from 'react';
+
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { CLAIM_TYPE_ID } from '~/core/claims/ontology';
@@ -20,22 +23,35 @@ vi.mock('~/core/state/feature-flags', () => ({
   useDebatesEnabled: () => mocks.debatesEnabled(),
 }));
 
+vi.mock('~/core/hooks/use-entity-vote', () => ({
+  useEntityResponseIndexingState: () => 'idle',
+  useEntityResponseIndexingSnapshot: () => ({ status: 'idle', pending: null, runId: null }),
+  useResetEntityResponseIndexingSnapshot: () => vi.fn(),
+}));
+
 vi.mock('~/core/sync/use-store', () => ({
   useQueryEntity: () => ({ entity: undefined }),
 }));
 
 vi.mock('./hooks', () => ({
+  useGeoChatAuth: () => ({ authenticated: true, accountKey: 'account-1' }),
   useDebateClaims: () => mocks.debateClaims(),
   useDebateActivity: () => ({ data: null }),
-  useJoinDebateQueue: () => ({ mutate: mocks.joinMutate, isPending: false, error: null }),
-  useLeaveDebateQueue: () => ({ mutate: mocks.leaveMutate, isPending: false, error: null }),
+  useJoinDebateQueue: () => ({ mutateAsync: mocks.joinMutate, reset: vi.fn(), isPending: false, error: null }),
+  useLeaveDebateQueue: () => ({ mutateAsync: mocks.leaveMutate, isPending: false, error: null }),
+}));
+
+vi.mock('~/partials/entity-page/entity-vote-buttons', () => ({
+  EntityVoteButtons: () => <div data-testid="entity-response-buttons">Entity response buttons</div>,
 }));
 
 beforeEach(() => {
   mocks.debatesEnabled.mockReturnValue(true);
   mocks.debateClaims.mockReturnValue({ data: { claims: [] } });
   mocks.joinMutate.mockReset();
+  mocks.joinMutate.mockReturnValue(new Promise(() => undefined));
   mocks.leaveMutate.mockReset();
+  mocks.leaveMutate.mockReturnValue(new Promise(() => undefined));
 });
 
 afterEach(() => {
@@ -50,62 +66,72 @@ function entity(relations: Entity['relations'], types: { id: string }[] = [{ id:
 
 function debateClaim(overrides: Partial<DebateClaim> = {}): DebateClaim {
   return {
+    id: 'debate-claim-1',
+    space_id: 'space-1',
     claim_entity_id: 'claim-entity-1',
+    claim: 'A claim',
+    description: null,
+    response_kind: 'stance',
+    viewer_response: null,
+    viewer_debate_ready: false,
+    readiness_disabled_reason: null,
+    readiness_changed_at: null,
     online_choices: [],
-    viewer_waiting_position: null,
     active_match: null,
     active_debate: null,
+    created_at: '2026-08-06T00:00:00.000Z',
+    updated_at: '2026-08-06T00:00:00.000Z',
     ...overrides,
   } as unknown as DebateClaim;
 }
 
-function openPopover() {
-  fireEvent.click(screen.getByRole('button', { name: 'Debate' }));
-}
-
 describe('ClaimDebateButton', () => {
   it('renders nothing when the entity is not a Claim', () => {
-    render(
+    renderButton(
       <ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity([], [{ id: 'not-a-claim' }])} />
     );
 
-    expect(screen.queryByRole('button', { name: 'Debate' })).not.toBeInTheDocument();
+    expect(screen.queryByRole('switch', { name: 'Debate' })).not.toBeInTheDocument();
   });
 
-  it('prompts to publish and disables the positions for an unpublished claim', () => {
-    render(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity(UNPUBLISHED)} />);
-    openPopover();
+  it('renders a disabled compact switch for an unpublished claim', () => {
+    renderButton(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity(UNPUBLISHED)} />);
 
-    expect(screen.getByText('Publish this claim before starting a debate.')).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /^Yes,/ })).toBeDisabled();
-    expect(screen.getByRole('button', { name: /^No,/ })).toBeDisabled();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
   });
 
-  it('enables the positions for a published claim and joins the queue on click', () => {
+  it('shows the disabled Debate switch before a claim response', () => {
     mocks.debateClaims.mockReturnValue({ data: { claims: [debateClaim()] } });
-    render(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity([])} />);
-    openPopover();
-
-    const yes = screen.getByRole('button', { name: /^Yes,/ });
-    expect(yes).toBeEnabled();
-    expect(yes).toHaveAttribute('aria-pressed', 'false');
+    renderButton(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity([])} />);
 
-    fireEvent.click(yes);
-    expect(mocks.joinMutate).toHaveBeenCalledWith({ claimId: 'claim-entity-1', request: { position: true } });
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
+    expect(screen.queryByText('Respond before debating', { selector: 'p' })).not.toBeInTheDocument();
   });
 
-  it('marks the chosen position selected while waiting and leaves the queue when clicked again', () => {
-    mocks.debateClaims.mockReturnValue({ data: { claims: [debateClaim({ viewer_waiting_position: true })] } });
-    render(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity([])} />);
-    openPopover();
-
-    const yes = screen.getByRole('button', { name: /^Yes,.*selected/ });
-    expect(yes).toHaveAttribute('aria-pressed', 'true');
-    expect(yes).toBeEnabled();
-    expect(screen.getByText('Waiting for someone with the opposite position.')).toBeInTheDocument();
-
-    fireEvent.click(yes);
+  it('shows the inline checked Debate switch and leaves when ready', () => {
+    mocks.debateClaims.mockReturnValue({
+      data: {
+        claims: [
+          debateClaim({
+            viewer_response: { position: true, position_label: 'Agree' },
+            viewer_debate_ready: true,
+          }),
+        ],
+      },
+    });
+    renderButton(<ClaimDebateButton entityId="claim-entity-1" spaceId="space-1" entity={entity([])} />);
+
+    const leave = screen.getByRole('switch', { name: 'Debate' });
+    expect(leave).toHaveAttribute('aria-checked', 'true');
+    expect(screen.queryByText('Waiting for someone with the opposite response.')).not.toBeInTheDocument();
+
+    fireEvent.click(leave);
     expect(mocks.leaveMutate).toHaveBeenCalledWith({ claimId: 'claim-entity-1' });
     expect(mocks.joinMutate).not.toHaveBeenCalled();
   });
 });
+
+function renderButton(button: ReactElement) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(<QueryClientProvider client={queryClient}>{button}</QueryClientProvider>);
+}
diff --git a/apps/web/core/debates/claim-debate-button.tsx b/apps/web/core/debates/claim-debate-button.tsx
index 6d0784531c..3b87aabc3d 100644
--- a/apps/web/core/debates/claim-debate-button.tsx
+++ b/apps/web/core/debates/claim-debate-button.tsx
@@ -1,233 +1,48 @@
 'use client';
 
-import * as Popover from '@radix-ui/react-popover';
-
-import * as React from 'react';
-
-import cx from 'classnames';
-
 import { CLAIM_TYPE_ID } from '~/core/claims/ontology';
 import { isClaimPublished } from '~/core/claims/publish';
 import { useDebatesEnabled } from '~/core/state/feature-flags';
 import { useQueryEntity } from '~/core/sync/use-store';
 import type { Entity } from '~/core/types';
 
-import { Avatar } from '~/design-system/avatar';
-import { Check } from '~/design-system/icons/check';
-import { Text } from '~/design-system/text';
-
-import type { DebateClaim, DebateOnlineChoice } from './api';
-import { useDebateActivity, useDebateClaims, useJoinDebateQueue, useLeaveDebateQueue } from './hooks';
+import { ClaimDebateReadiness } from './claim-debate-readiness';
+import { useDebateActivity, useDebateClaims } from './hooks';
 
 type ClaimDebateButtonProps = {
   entityId: string;
   spaceId: string;
-  /**
-   * The entity, if the parent already subscribes to it (e.g. the entity-page
-   * header). Passing it avoids a duplicate `useQueryEntity` subscription on the
-   * entity-page hot path; omit it to let the button fetch on its own.
-   */
+  /** Avoids a duplicate entity subscription when the parent already has the entity. */
   entity?: Entity | null;
 };
 
-const positions = [
-  { label: 'Yes', value: true },
-  { label: 'No', value: false },
-] as const;
-
 export function ClaimDebateButton({ entityId, spaceId, entity: providedEntity }: ClaimDebateButtonProps) {
   const isDebatesEnabled = useDebatesEnabled();
-
   const { entity: fetchedEntity } = useQueryEntity({
     id: entityId,
     spaceId,
     enabled: isDebatesEnabled && providedEntity == null,
   });
   const entity = providedEntity ?? fetchedEntity;
-
   const isClaim = entity?.types.some(type => type.id === CLAIM_TYPE_ID) ?? false;
   const published = entity ? isClaimPublished(entity) : false;
 
   const debateClaimsQuery = useDebateClaims(spaceId, published ? [entityId] : [], isDebatesEnabled && isClaim);
   const debateClaim = debateClaimsQuery.data?.claims.find(claim => claim.claim_entity_id === entityId) ?? null;
-
-  const activityQuery = useDebateActivity(isDebatesEnabled && isClaim);
-  const activity = activityQuery.data ?? null;
+  const activity = useDebateActivity(isDebatesEnabled && isClaim).data ?? null;
   const hasActiveFlowElsewhere = Boolean(activity?.match || activity?.debate || activity?.rematch);
 
-  const joinQueue = useJoinDebateQueue(spaceId);
-  const leaveQueue = useLeaveDebateQueue(spaceId);
-
   if (!isDebatesEnabled || !isClaim) return null;
 
-  const activeMatch = debateClaim?.active_match ?? null;
-  const activeDebate = debateClaim?.active_debate ?? null;
-  const canJoinDebate = published && !activeDebate && !activeMatch && !hasActiveFlowElsewhere;
-  const isMutating = joinQueue.isPending || leaveQueue.isPending;
-  const mutationError =
-    joinQueue.error instanceof Error
-      ? joinQueue.error.message
-      : leaveQueue.error instanceof Error
-        ? leaveQueue.error.message
-        : null;
-
-  // Clicking the position you're already waiting on leaves the queue.
-  const togglePosition = (position: boolean) => {
-    if (debateClaim?.viewer_waiting_position === position) {
-      leaveQueue.mutate({ claimId: entityId });
-    } else {
-      joinQueue.mutate({ claimId: entityId, request: { position } });
-    }
-  };
+  const canEnable = published && !debateClaim?.active_debate && !debateClaim?.active_match && !hasActiveFlowElsewhere;
 
   return (
-    <Popover.Root>
-      <Popover.Trigger asChild>
-        <button
-          type="button"
-          className={cx(
-            'inline-flex h-7 items-center rounded-full border px-3 text-button transition-colors',
-            'border-grey-02 bg-white text-text hover:border-text',
-            'data-[state=open]:border-text data-[state=open]:bg-text data-[state=open]:text-white'
-          )}
-        >
-          Debate
-        </button>
-      </Popover.Trigger>
-      <Popover.Portal>
-        <Popover.Content
-          align="end"
-          side="bottom"
-          sideOffset={8}
-          className="z-100 w-[305px] rounded-xl border border-grey-02 bg-white p-5 text-text shadow-lg"
-        >
-          <Text as="h3" variant="smallTitle" color="text">
-            Debate this claim
-          </Text>
-          <Text as="p" variant="metadata" color="grey-04" className="mt-1">
-            Select your position and start matchmaking
-          </Text>
-
-          <div className="mt-5 grid grid-cols-2 gap-2">
-            {positions.map(position => {
-              const choice = debateClaim?.online_choices.find(choice => choice.position === position.value) ?? null;
-              const label = choice?.position_label ?? position.label;
-              const participantCount = choice?.participant_count ?? 0;
-              const selected = debateClaim?.viewer_waiting_position === position.value;
-              const accessibleLabel = `${label}, ${participantCount} participant${participantCount === 1 ? '' : 's'} available${selected ? ', selected' : ''}`;
-
-              return (
-                <button
-                  key={position.label}
-                  type="button"
-                  aria-label={accessibleLabel}
-                  aria-pressed={selected}
-                  onClick={() => togglePosition(position.value)}
-                  disabled={!canJoinDebate || isMutating}
-                  className={cx(
-                    'flex min-h-7 min-w-0 items-center justify-between gap-2 rounded-full px-3 text-button transition-colors disabled:opacity-60',
-                    selected ? (position.value ? 'bg-green text-text' : 'bg-red-01 text-text') : 'bg-bg text-text'
-                  )}
-                >
-                  <span className="flex min-w-0 items-center gap-1.5">
-                    {selected && (
-                      <span aria-hidden="true" className="shrink-0">
-                        <Check />
-                      </span>
-                    )}
-                    <span className="truncate">{label}</span>
-                  </span>
-                  {choice && <OnlineChoiceParticipants choice={choice} />}
-                </button>
-              );
-            })}
-          </div>
-
-          <ClaimDebateStatus debateClaim={debateClaim} mutationError={mutationError} published={published} />
-        </Popover.Content>
-      </Popover.Portal>
-    </Popover.Root>
+    <ClaimDebateReadiness
+      debateClaim={debateClaim}
+      entityId={entityId}
+      spaceId={spaceId}
+      canEnable={canEnable}
+      compact
+    />
   );
 }
-
-function OnlineChoiceParticipants({ choice }: { choice: DebateOnlineChoice }) {
-  const participants = choice.participants.slice(0, 2);
-  const overflowCount = Math.max(0, choice.participant_count - participants.length);
-
-  if (participants.length === 0 && overflowCount === 0) return null;
-
-  return (
-    <span aria-hidden="true" className="flex shrink-0 items-center -space-x-2">
-      {participants.map(participant => {
-        const label = participant.display_name || participant.profile_space_id;
-
-        return (
-          <span
-            key={participant.user_id}
-            title={label}
-            className="relative box-content block h-5 w-5 overflow-hidden rounded-full border-2 border-white"
-          >
-            <Avatar avatarUrl={participant.avatar_cid} value={participant.profile_space_id} alt={label} size={20} />
-          </span>
-        );
-      })}
-      {overflowCount > 0 && (
-        <span className="relative box-content flex h-5 min-w-5 items-center justify-center rounded-full border-2 border-white bg-grey-02 px-1 text-[11px] leading-5 text-grey-04 tabular-nums">
-          +{overflowCount}
-        </span>
-      )}
-    </span>
-  );
-}
-
-function ClaimDebateStatus({
-  debateClaim,
-  mutationError,
-  published,
-}: {
-  debateClaim: DebateClaim | null;
-  mutationError: string | null;
-  published: boolean;
-}) {
-  if (mutationError) {
-    return (
-      <Text as="p" variant="metadata" color="red-01" className="mt-3">
-        {mutationError}
-      </Text>
-    );
-  }
-
-  if (!published) {
-    return (
-      <Text as="p" variant="metadata" color="grey-04" className="mt-3">
-        Publish this claim before starting a debate.
-      </Text>
-    );
-  }
-
-  if (debateClaim?.active_debate) {
-    return (
-      <Text as="p" variant="metadata" color="grey-04" className="mt-3">
-        Debate {debateClaim.active_debate.status.replace('_', ' ')}
-      </Text>
-    );
-  }
-
-  if (debateClaim?.active_match) {
-    return (
-      <Text as="p" variant="metadata" color="grey-04" className="mt-3">
-        Match found. Both speakers need to accept.
-      </Text>
-    );
-  }
-
-  if (debateClaim?.viewer_waiting_position !== null && debateClaim?.viewer_waiting_position !== undefined) {
-    return (
-      <Text as="p" variant="metadata" color="grey-04" className="mt-3">
-        Waiting for someone with the opposite position.
-      </Text>
-    );
-  }
-
-  return null;
-}
diff --git a/apps/web/core/debates/claim-debate-readiness.test.tsx b/apps/web/core/debates/claim-debate-readiness.test.tsx
new file mode 100644
index 0000000000..2fd226e37b
--- /dev/null
+++ b/apps/web/core/debates/claim-debate-readiness.test.tsx
@@ -0,0 +1,588 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import '@testing-library/jest-dom/vitest';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+
+import type { ReactElement } from 'react';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { entityResponseIndexingQueryKey } from '~/core/responses/entity-response';
+
+import { type DebateClaim, GeoChatRequestError } from './api';
+import { ClaimDebateReadiness } from './claim-debate-readiness';
+
+const mocks = vi.hoisted(() => ({
+  joinMutateAsync: vi.fn(),
+  joinReset: vi.fn(),
+  leaveMutateAsync: vi.fn(),
+  responseKinds: [] as Array<'stance' | 'veracity' | null>,
+  authenticated: true,
+  accountKey: 'account-1' as string | null,
+}));
+
+vi.mock('./hooks', () => ({
+  useGeoChatAuth: () => ({ authenticated: mocks.authenticated, accountKey: mocks.accountKey }),
+  useJoinDebateQueue: () => ({
+    mutateAsync: mocks.joinMutateAsync,
+    reset: mocks.joinReset,
+    isPending: false,
+    error: null,
+  }),
+  useLeaveDebateQueue: () => ({ mutateAsync: mocks.leaveMutateAsync, isPending: false, error: null }),
+}));
+
+vi.mock('~/core/hooks/use-personal-space-id', () => ({
+  usePersonalSpaceId: () => ({ personalSpaceId: 'profile-space-1', isRegistered: true }),
+}));
+
+vi.mock('~/partials/entity-page/entity-vote-buttons', () => ({
+  EntityVoteButtons: ({ responseKind }: { responseKind: 'stance' | 'veracity' | null }) => {
+    mocks.responseKinds.push(responseKind);
+    return <div data-testid="entity-response-buttons">Entity response buttons</div>;
+  },
+}));
+
+beforeEach(() => {
+  mocks.joinMutateAsync.mockReset();
+  mocks.joinMutateAsync.mockReturnValue(deferred().promise);
+  mocks.joinReset.mockReset();
+  mocks.leaveMutateAsync.mockReset();
+  mocks.leaveMutateAsync.mockReturnValue(deferred(queueResponse(false)).promise);
+  mocks.responseKinds.length = 0;
+  mocks.authenticated = true;
+  mocks.accountKey = 'account-1';
+});
+
+afterEach(cleanup);
+
+describe('ClaimDebateReadiness', () => {
+  it('shows the disabled Debate switch until the user responds', () => {
+    renderReadiness(claim({ viewer_response: null }));
+
+    expect(screen.getByTestId('entity-response-buttons')).toBeInTheDocument();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
+    expect(screen.queryByText(/join debate|cancel join|check again/i)).not.toBeInTheDocument();
+  });
+
+  it('places the response controls and Debate switch in one action row', () => {
+    renderReadiness(claim());
+
+    const actionRow = screen.getByTestId('entity-response-buttons').parentElement;
+    expect(actionRow).toBe(screen.getByRole('switch', { name: 'Debate' }).parentElement);
+    expect(actionRow).toHaveClass('flex', 'items-center', 'gap-4');
+  });
+
+  it('optimistically enables persisted readiness through the Debate switch', async () => {
+    renderReadiness(claim({ viewer_response: { position: false, position_label: 'Disagree' } }));
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledTimes(1));
+    expect(mocks.joinMutateAsync).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
+
+  it('hands control back to a newer backend disable after the join is confirmed', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    const view = renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+
+    await act(() => join.resolve(queueResponse(true)));
+    view.rerender(readiness(claim({ viewer_debate_ready: true }), view.queryClient));
+    await waitFor(() => expect(screen.getByRole('switch', { name: 'Debate' })).not.toHaveAttribute('aria-busy'));
+
+    view.rerender(readiness(claim({ viewer_debate_ready: false }), view.queryClient));
+
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('stays clickable while joining and serializes a later leave', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+    expect(toggle).toHaveAttribute('aria-busy', 'true');
+    expect(toggle).toBeEnabled();
+
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(mocks.leaveMutateAsync).not.toHaveBeenCalled();
+
+    await act(() => join.resolve());
+
+    await waitFor(() => expect(mocks.leaveMutateAsync).toHaveBeenCalledOnce());
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('stays clickable while leaving and serializes a later join', async () => {
+    const leave = deferred(queueResponse(false));
+    mocks.leaveMutateAsync.mockReturnValueOnce(leave.promise);
+    renderReadiness(claim({ viewer_debate_ready: true }));
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+
+    expect(mocks.leaveMutateAsync).toHaveBeenCalledOnce();
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(toggle).toHaveAttribute('aria-busy', 'true');
+    expect(toggle).toBeEnabled();
+
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+
+    await act(() => leave.resolve());
+
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('collapses rapid reversals to the final desired readiness', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+
+    fireEvent.click(toggle);
+    fireEvent.click(toggle);
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+
+    await act(() => join.resolve());
+
+    await waitFor(() => expect(toggle).not.toHaveAttribute('aria-busy'));
+    expect(mocks.joinMutateAsync).toHaveBeenCalledOnce();
+    expect(mocks.leaveMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('preserves an in-flight readiness intent across client-side navigation', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    const view = renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    view.unmount();
+
+    const remounted = render(readiness(claim(), view.queryClient));
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'true');
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-busy', 'true');
+
+    await act(() => join.resolve());
+
+    await waitFor(() => expect(screen.getByRole('switch', { name: 'Debate' })).not.toHaveAttribute('aria-busy'));
+    expect(mocks.joinMutateAsync).toHaveBeenCalledOnce();
+    remounted.rerender(readiness(claim({ viewer_debate_ready: true }), view.queryClient));
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('preserves the final reversal across client-side navigation', async () => {
+    const join = deferred();
+    const leave = deferred(queueResponse(false));
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    mocks.leaveMutateAsync.mockReturnValueOnce(leave.promise);
+    const view = renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    fireEvent.click(toggle);
+    view.unmount();
+
+    render(readiness(claim(), view.queryClient));
+    await act(() => join.resolve());
+
+    await waitFor(() => expect(mocks.leaveMutateAsync).toHaveBeenCalledOnce());
+    await act(() => leave.resolve());
+    await waitFor(() => expect(screen.getByRole('switch', { name: 'Debate' })).not.toHaveAttribute('aria-busy'));
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('starts one request when duplicate controls share the same readiness intent', async () => {
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <ClaimDebateReadiness debateClaim={claim()} entityId="claim-1" spaceId="space-1" canEnable compact />
+        <ClaimDebateReadiness debateClaim={claim()} entityId="claim-1" spaceId="space-1" canEnable compact />
+      </QueryClientProvider>
+    );
+
+    fireEvent.click(screen.getAllByRole('switch', { name: 'Debate' })[0]);
+
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    expect(screen.getAllByRole('switch', { name: 'Debate' })[0]).toHaveAttribute('aria-checked', 'true');
+    expect(screen.getAllByRole('switch', { name: 'Debate' })[1]).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('turns persisted readiness off through the same switch', () => {
+    renderReadiness(claim({ viewer_debate_ready: true }));
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+    expect(screen.queryByText('Waiting for someone with the opposite response.')).not.toBeInTheDocument();
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(mocks.leaveMutateAsync).toHaveBeenCalledWith({ claimId: 'claim-1' });
+  });
+
+  it('allows optimistic readiness before indexing without calling geo-chat', () => {
+    renderReadiness(claim({ viewer_response: null }), indexing('positive'));
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    expect(toggle).toBeEnabled();
+
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+    expect(screen.queryByText(/processing response|join debate|cancel join|check again/i)).not.toBeInTheDocument();
+  });
+
+  it('submits readiness exactly once after geo-chat confirms the expected response', async () => {
+    const view = renderReadiness(claim({ viewer_response: null }), indexing('negative'));
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+
+    view.rerender(
+      readiness(claim({ viewer_response: { position: false, position_label: 'Disagree' } }), view.queryClient)
+    );
+
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledTimes(1));
+    view.rerender(
+      readiness(claim({ viewer_response: { position: false, position_label: 'Disagree' } }), view.queryClient)
+    );
+    expect(mocks.joinMutateAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it('turns the optimistic switch off to cancel readiness before confirmation', () => {
+    renderReadiness(claim({ viewer_response: null }), indexing('positive'));
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    fireEvent.click(toggle);
+
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('clears optimistic readiness when the response transaction fails', async () => {
+    const view = renderReadiness(claim({ viewer_response: null }), indexing('positive'));
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+
+    await act(async () => {
+      view.queryClient.setQueryData(
+        entityResponseIndexingQueryKey('profile-space-1', 'claim-1', 'space-1', 'stance'),
+        idleIndexingState()
+      );
+    });
+
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(toggle).toBeDisabled();
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('turns readiness off immediately when the response is optimistically withdrawn', () => {
+    renderReadiness(claim({ viewer_debate_ready: true }), indexingClear());
+
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+    expect(screen.queryByText('Waiting for someone with the opposite response.')).not.toBeInTheDocument();
+    expect(mocks.leaveMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('refetches and retries once when geo-chat has not observed the response yet', async () => {
+    mocks.joinMutateAsync.mockRejectedValueOnce(
+      new GeoChatRequestError('Respond before debating', 'claim_response_required', 409)
+    );
+    renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledTimes(2));
+    expect(mocks.joinReset).toHaveBeenCalledOnce();
+    expect(screen.queryByText('Respond before debating', { selector: '.text-red-01' })).not.toBeInTheDocument();
+  });
+
+  it('does not retry claim_response_required after the user switches Debate off', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    fireEvent.click(toggle);
+
+    await act(() => join.reject(new GeoChatRequestError('Respond before debating', 'claim_response_required', 409)));
+
+    await waitFor(() => expect(toggle).not.toHaveAttribute('aria-busy'));
+    expect(mocks.joinMutateAsync).toHaveBeenCalledOnce();
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(screen.queryByText('Respond before debating')).not.toBeInTheDocument();
+  });
+
+  it('clears readiness intent when a validation refetch removes the server response', async () => {
+    mocks.joinMutateAsync.mockRejectedValueOnce(
+      new GeoChatRequestError('Respond before debating', 'claim_response_required', 409)
+    );
+    const view = renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    view.rerender(readiness(claim({ viewer_response: null }), view.queryClient));
+
+    await waitFor(() =>
+      expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false')
+    );
+    expect(mocks.joinMutateAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it('retires an indexed response after the debate payload confirms it', async () => {
+    const view = renderReadiness(claim(), indexed('positive'));
+
+    await waitFor(() =>
+      expect(
+        view.queryClient.getQueryData(entityResponseIndexingQueryKey('profile-space-1', 'claim-1', 'space-1', 'stance'))
+      ).toEqual(idleIndexingState())
+    );
+  });
+
+  it('clears optimistic readiness and surfaces non-transient queue errors', async () => {
+    mocks.joinMutateAsync.mockRejectedValueOnce(new Error('Queue unavailable'));
+    renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+
+    await waitFor(() => expect(screen.getByText('Queue unavailable')).toBeInTheDocument());
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('preserves queue failure feedback across client-side navigation', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    const view = renderReadiness(claim());
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    view.unmount();
+    await act(() => join.reject(new Error('Queue unavailable')));
+
+    render(readiness(claim(), view.queryClient));
+
+    expect(await screen.findByText('Queue unavailable')).toBeInTheDocument();
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+  });
+
+  it('rolls a failed leave back to the confirmed ready state', async () => {
+    mocks.leaveMutateAsync.mockRejectedValueOnce(new Error('Leave unavailable'));
+    renderReadiness(claim({ viewer_debate_ready: true }));
+
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+
+    await waitFor(() => expect(screen.getByText('Leave unavailable')).toBeInTheDocument());
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('rolls back to a newly confirmed join when the serialized leave fails', async () => {
+    const join = deferred();
+    const leave = deferred(queueResponse(false));
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    mocks.leaveMutateAsync.mockReturnValueOnce(leave.promise);
+    renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    fireEvent.click(toggle);
+    await act(() => join.resolve());
+    await waitFor(() => expect(mocks.leaveMutateAsync).toHaveBeenCalledOnce());
+
+    await act(() => leave.reject(new Error('Leave unavailable')));
+
+    await waitFor(() => expect(screen.getByText('Leave unavailable')).toBeInTheDocument());
+    expect(toggle).toHaveAttribute('aria-checked', 'true');
+  });
+
+  it('suppresses an obsolete join error when the final desired state is already confirmed', async () => {
+    const join = deferred();
+    mocks.joinMutateAsync.mockReturnValueOnce(join.promise);
+    renderReadiness(claim());
+
+    const toggle = screen.getByRole('switch', { name: 'Debate' });
+    fireEvent.click(toggle);
+    await waitFor(() => expect(mocks.joinMutateAsync).toHaveBeenCalledOnce());
+    fireEvent.click(toggle);
+
+    await act(() => join.reject(new Error('Queue unavailable')));
+
+    await waitFor(() => expect(toggle).not.toHaveAttribute('aria-busy'));
+    expect(toggle).toHaveAttribute('aria-checked', 'false');
+    expect(screen.queryByText('Queue unavailable')).not.toBeInTheDocument();
+  });
+
+  it('cancels pending readiness when the response kind changes', () => {
+    const view = renderReadiness(claim({ viewer_response: null }), indexing('positive'));
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+
+    view.rerender(readiness(claim({ response_kind: 'veracity', viewer_response: null }), view.queryClient));
+
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeDisabled();
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('cancels pending readiness when the user signs out', () => {
+    const view = renderReadiness(claim({ viewer_response: null }), indexing('positive'));
+    fireEvent.click(screen.getByRole('switch', { name: 'Debate' }));
+
+    mocks.authenticated = false;
+    mocks.accountKey = null;
+    view.rerender(readiness(claim({ viewer_response: null }), view.queryClient));
+
+    expect(screen.getByRole('switch', { name: 'Debate' })).toHaveAttribute('aria-checked', 'false');
+    expect(mocks.joinMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it('renders only the compact Debate switch in claim action rows', () => {
+    renderReadiness(claim(), idleIndexingState(), true);
+
+    expect(screen.getByRole('switch', { name: 'Debate' })).toBeInTheDocument();
+    expect(screen.queryByText('Ready to debate')).not.toBeInTheDocument();
+    expect(screen.queryByText(/your response/i)).not.toBeInTheDocument();
+  });
+
+  it.each([
+    ['claim_response_kind_changed', 'This claim’s response type changed. Respond and enable Debate again.'],
+    [
+      'claim_response_validation_failed',
+      'Your response could not be verified yet. Debate will remain enabled while verification retries.',
+    ],
+  ])('turns %s into an actionable readiness message', (reason, message) => {
+    renderReadiness(claim({ readiness_disabled_reason: reason }));
+
+    expect(screen.getByText(message)).toBeInTheDocument();
+  });
+
+  it.each(['user_disabled', 'claim_response_withdrawn'])('does not expose %s lifecycle state', reason => {
+    renderReadiness(claim({ readiness_disabled_reason: reason }));
+
+    expect(screen.queryByText(reason)).not.toBeInTheDocument();
+    expect(screen.queryByText('Your response was withdrawn, so Debate was turned off.')).not.toBeInTheDocument();
+  });
+});
+
+type IndexingState =
+  | ReturnType<typeof idleIndexingState>
+  | ReturnType<typeof indexing>
+  | ReturnType<typeof indexingClear>
+  | ReturnType<typeof indexed>;
+
+function renderReadiness(
+  debateClaim: DebateClaim,
+  indexingState: IndexingState = idleIndexingState(),
+  compact = false
+) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  queryClient.setQueryData(
+    entityResponseIndexingQueryKey('profile-space-1', 'claim-1', 'space-1', debateClaim.response_kind),
+    indexingState
+  );
+
+  return { queryClient, ...render(readiness(debateClaim, queryClient, compact)) };
+}
+
+function readiness(debateClaim: DebateClaim, queryClient: QueryClient, compact = false): ReactElement {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <ClaimDebateReadiness
+        debateClaim={debateClaim}
+        entityId="claim-1"
+        spaceId="space-1"
+        canEnable
+        textVariant="metadata"
+        compact={compact}
+      />
+    </QueryClientProvider>
+  );
+}
+
+function idleIndexingState() {
+  return { status: 'idle' as const, pending: null, runId: null };
+}
+
+function indexing(expectedResponse: 'positive' | 'negative') {
+  return {
+    status: 'reconciling' as const,
+    pending: {
+      entityId: 'claim-1',
+      expectedResponse,
+      personalSpaceId: 'profile-space-1',
+      responseKind: 'stance' as const,
+      spaceId: 'space-1',
+    },
+    runId: 'response-run-1',
+  };
+}
+
+function indexingClear() {
+  return {
+    ...indexing('positive'),
+    pending: { ...indexing('positive').pending, expectedResponse: null },
+  };
+}
+
+function indexed(expectedResponse: 'positive' | 'negative') {
+  return { ...indexing(expectedResponse), status: 'indexed' as const };
+}
+
+function claim(overrides: Partial<DebateClaim> = {}): DebateClaim {
+  return {
+    id: 'debate-claim-1',
+    space_id: 'space-1',
+    claim_entity_id: 'claim-1',
+    claim: 'A claim',
+    description: null,
+    response_kind: 'stance',
+    viewer_response: { position: true, position_label: 'Agree' },
+    viewer_debate_ready: false,
+    readiness_disabled_reason: null,
+    readiness_changed_at: null,
+    online_choices: [],
+    active_match: null,
+    active_debate: null,
+    created_at: '2026-08-06T00:00:00.000Z',
+    updated_at: '2026-08-06T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function queueResponse(viewerDebateReady: boolean) {
+  return { claim: claim({ viewer_debate_ready: viewerDebateReady }), match: null };
+}
+
+function deferred(defaultValue: unknown = queueResponse(true)) {
+  let resolve!: (value?: unknown) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<unknown>((promiseResolve, promiseReject) => {
+    resolve = value => promiseResolve(value ?? defaultValue);
+    reject = promiseReject;
+  });
+  return { promise, resolve, reject };
+}
diff --git a/apps/web/core/debates/claim-debate-readiness.tsx b/apps/web/core/debates/claim-debate-readiness.tsx
new file mode 100644
index 0000000000..094689e3b3
--- /dev/null
+++ b/apps/web/core/debates/claim-debate-readiness.tsx
@@ -0,0 +1,364 @@
+'use client';
+
+import { useQueryClient } from '@tanstack/react-query';
+
+import * as React from 'react';
+
+import cx from 'classnames';
+
+import {
+  useEntityResponseIndexingSnapshot,
+  useResetEntityResponseIndexingSnapshot,
+} from '~/core/hooks/use-entity-vote';
+
+import { Text } from '~/design-system/text';
+import { Toggle } from '~/design-system/toggle';
+
+import { type DebateClaim, type DebateClaimsResponse, GeoChatRequestError } from './api';
+import { DebateEntityResponseControls } from './debate-entity-response-controls';
+import { useDebateReadinessIntent } from './debate-readiness-intent';
+import { useGeoChatAuth, useJoinDebateQueue, useLeaveDebateQueue } from './hooks';
+
+type ClaimDebateReadinessProps = {
+  debateClaim: DebateClaim | null;
+  entityId: string;
+  spaceId: string;
+  canEnable: boolean;
+  className?: string;
+  textVariant?: 'metadata' | 'body';
+  compact?: boolean;
+};
+
+export function ClaimDebateReadiness({
+  debateClaim,
+  entityId,
+  spaceId,
+  canEnable,
+  className,
+  textVariant = 'metadata',
+  compact = false,
+}: ClaimDebateReadinessProps) {
+  if (!debateClaim) {
+    return compact ? (
+      <DebateToggle checked={false} disabled className={className} title="Debate readiness is loading" />
+    ) : null;
+  }
+
+  return (
+    <ClaimDebateReadinessContent
+      debateClaim={debateClaim}
+      entityId={entityId}
+      spaceId={spaceId}
+      canEnable={canEnable}
+      className={className}
+      textVariant={textVariant}
+      compact={compact}
+    />
+  );
+}
+
+function ClaimDebateReadinessContent({
+  debateClaim,
+  entityId,
+  spaceId,
+  canEnable,
+  className,
+  textVariant = 'metadata',
+  compact = false,
+}: Omit<ClaimDebateReadinessProps, 'debateClaim'> & { debateClaim: DebateClaim }) {
+  const queryClient = useQueryClient();
+  const joinQueue = useJoinDebateQueue(spaceId);
+  const leaveQueue = useLeaveDebateQueue(spaceId);
+  const { accountKey, authenticated } = useGeoChatAuth();
+  const responseIndexing = useEntityResponseIndexingSnapshot({
+    entityId,
+    spaceId,
+    responseKind: debateClaim.response_kind,
+  });
+  const resetResponseIndexing = useResetEntityResponseIndexingSnapshot({
+    entityId,
+    spaceId,
+    responseKind: debateClaim.response_kind,
+  });
+  const { intent, setIntent, updateIntent } = useDebateReadinessIntent(
+    accountKey,
+    spaceId,
+    entityId,
+    debateClaim.response_kind
+  );
+
+  const pendingResponse = responseIndexing.status === 'idle' ? null : responseIndexing.pending;
+  const optimisticPosition =
+    pendingResponse?.expectedResponse == null ? null : pendingResponse.expectedResponse === 'positive';
+  const viewerPosition = pendingResponse ? optimisticPosition : (debateClaim.viewer_response?.position ?? null);
+  const backendReady = debateClaim.viewer_debate_ready;
+  const responseWithdrawalPending = Boolean(pendingResponse && pendingResponse.expectedResponse === null);
+  const checked = responseWithdrawalPending ? false : (intent?.desiredReady ?? backendReady);
+  const intentRequestInFlight = intent?.inFlightReady !== null && intent?.inFlightReady !== undefined;
+  const isSaving = intentRequestInFlight || joinQueue.isPending || leaveQueue.isPending;
+  const canEnableToggle = viewerPosition !== null && authenticated && canEnable;
+  const disabled = !checked && !canEnableToggle;
+
+  React.useEffect(
+    function reconcileReadinessIntent() {
+      if (!intent) return;
+      if (!authenticated || !accountKey) {
+        setIntent(null);
+        return;
+      }
+
+      if (responseWithdrawalPending) {
+        setIntent(null);
+        return;
+      }
+
+      if (intent.inFlightReady !== null) return;
+      if (intent.refreshing) return;
+
+      if (intent.desiredReady === intent.confirmedReady) {
+        if (backendReady === intent.confirmedReady && !intent.error) setIntent(null);
+        return;
+      }
+
+      if (intent.desiredReady && intent.responseRunId) {
+        if (responseIndexing.status === 'idle' || responseIndexing.runId !== intent.responseRunId) {
+          setIntent(null);
+          return;
+        }
+        if (
+          !responseIndexing.pending?.expectedResponse ||
+          (responseIndexing.pending.expectedResponse === 'positive') !== intent.expectedPosition
+        ) {
+          setIntent(null);
+          return;
+        }
+      }
+
+      if (intent.desiredReady && debateClaim.viewer_response?.position !== intent.expectedPosition) {
+        if (!intent.responseRunId || responseIndexing.status === 'idle') setIntent(null);
+        return;
+      }
+
+      const submittedReady = intent.desiredReady;
+      let requestStarted = false;
+      updateIntent(current => {
+        if (
+          !current ||
+          current.inFlightReady !== null ||
+          current.refreshing ||
+          current.desiredReady !== submittedReady
+        ) {
+          return current;
+        }
+        requestStarted = true;
+        return { ...current, inFlightReady: submittedReady };
+      });
+      if (!requestStarted) return;
+
+      const request = submittedReady
+        ? joinQueue.mutateAsync({ claimId: entityId })
+        : leaveQueue.mutateAsync({ claimId: entityId });
+
+      void request.then(
+        result => {
+          queryClient.setQueriesData<DebateClaimsResponse>({ queryKey: ['debates', 'claims', spaceId] }, current =>
+            current
+              ? {
+                  ...current,
+                  claims: current.claims.map(claim =>
+                    claim.claim_entity_id === result.claim.claim_entity_id ? result.claim : claim
+                  ),
+                }
+              : current
+          );
+          updateIntent(current => {
+            if (current?.inFlightReady !== submittedReady) return current;
+            return {
+              ...current,
+              confirmedReady: submittedReady,
+              inFlightReady: null,
+              error: null,
+            };
+          });
+        },
+        error => {
+          let retryAfterRefetch = false;
+          updateIntent(current => {
+            if (current?.inFlightReady !== submittedReady) return current;
+            if (
+              submittedReady &&
+              current.desiredReady &&
+              error instanceof GeoChatRequestError &&
+              error.code === 'claim_response_required' &&
+              !current.hasRetried
+            ) {
+              retryAfterRefetch = true;
+              return {
+                ...current,
+                hasRetried: true,
+                inFlightReady: null,
+                refreshing: true,
+                error: null,
+              };
+            }
+
+            const requestError =
+              current.desiredReady !== current.confirmedReady
+                ? error instanceof Error
+                  ? error.message
+                  : 'Could not update debate readiness.'
+                : null;
+            return {
+              ...current,
+              desiredReady: current.confirmedReady,
+              inFlightReady: null,
+              refreshing: false,
+              error: requestError,
+            };
+          });
+
+          if (retryAfterRefetch) {
+            joinQueue.reset();
+            void queryClient.refetchQueries({ queryKey: ['debates', 'claims', spaceId] }).finally(() => {
+              updateIntent(current =>
+                current?.desiredReady && current.refreshing ? { ...current, refreshing: false } : current
+              );
+            });
+            return;
+          }
+        }
+      );
+    },
+    [
+      accountKey,
+      authenticated,
+      backendReady,
+      debateClaim.viewer_response?.position,
+      entityId,
+      intent,
+      joinQueue,
+      queryClient,
+      responseIndexing,
+      responseWithdrawalPending,
+      setIntent,
+      spaceId,
+      updateIntent,
+    ]
+  );
+
+  React.useEffect(
+    function retireConfirmedOptimisticResponse() {
+      if (responseIndexing.status !== 'indexed') return;
+      const expectedResponse = responseIndexing.pending.expectedResponse;
+      const confirmed =
+        expectedResponse === null
+          ? debateClaim.viewer_response === null
+          : debateClaim.viewer_response?.position === (expectedResponse === 'positive');
+      if (confirmed) resetResponseIndexing(responseIndexing.runId);
+    },
+    [debateClaim.viewer_response, resetResponseIndexing, responseIndexing]
+  );
+
+  const handleToggle = () => {
+    const desiredReady = !checked;
+    if (desiredReady && (viewerPosition === null || !canEnableToggle)) return;
+
+    setIntent({
+      desiredReady,
+      confirmedReady: intent?.confirmedReady ?? backendReady,
+      inFlightReady: intent?.inFlightReady ?? null,
+      expectedPosition: desiredReady ? viewerPosition : (intent?.expectedPosition ?? viewerPosition),
+      responseRunId: desiredReady ? (pendingResponse ? responseIndexing.runId : null) : (intent?.responseRunId ?? null),
+      hasRetried: desiredReady ? false : (intent?.hasRetried ?? false),
+      refreshing: false,
+      error: null,
+    });
+  };
+
+  const toggle = (
+    <DebateToggle
+      checked={checked}
+      disabled={disabled}
+      busy={isSaving}
+      className={compact ? className : undefined}
+      onClick={handleToggle}
+    />
+  );
+
+  if (compact) return toggle;
+
+  const readinessMessage = readinessReasonMessage(debateClaim.readiness_disabled_reason);
+
+  return (
+    <div className={className}>
+      <div className="flex items-center gap-4">
+        <DebateEntityResponseControls entityId={entityId} spaceId={spaceId} responseKind={debateClaim.response_kind} />
+        {toggle}
+      </div>
+
+      {(intent?.error || readinessMessage) && (
+        <Text as="p" variant={textVariant} color="red-01" className="mt-2">
+          {intent?.error ?? readinessMessage}
+        </Text>
+      )}
+    </div>
+  );
+}
+
+function DebateToggle({
+  checked,
+  disabled,
+  busy = false,
+  className,
+  onClick,
+  title,
+}: {
+  checked: boolean;
+  disabled: boolean;
+  busy?: boolean;
+  className?: string;
+  onClick?: () => void;
+  title?: string;
+}) {
+  const descriptionId = React.useId();
+
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-checked={checked}
+      aria-busy={busy || undefined}
+      aria-label="Debate"
+      aria-describedby={disabled && title ? descriptionId : undefined}
+      disabled={disabled}
+      onClick={onClick}
+      title={title}
+      className={cx(
+        'inline-flex h-7 cursor-pointer items-center gap-2 rounded-sm text-button text-grey-04 transition-opacity focus-visible:outline focus-visible:outline-2 focus-visible:outline-text disabled:cursor-default disabled:opacity-50',
+        className
+      )}
+    >
+      <Toggle checked={checked} className="shrink-0" />
+      <span>Debate</span>
+      {disabled && title && (
+        <span id={descriptionId} className="sr-only">
+          {title}
+        </span>
+      )}
+    </button>
+  );
+}
+
+function readinessReasonMessage(reason: string | null) {
+  switch (reason) {
+    case 'user_disabled':
+    case 'claim_response_withdrawn':
+      return null;
+    case 'claim_response_kind_changed':
+      return 'This claim’s response type changed. Respond and enable Debate again.';
+    case 'claim_response_validation_failed':
+      return 'Your response could not be verified yet. Debate will remain enabled while verification retries.';
+    default:
+      return reason;
+  }
+}
diff --git a/apps/web/core/debates/claim-response-indexed-notifier.test.tsx b/apps/web/core/debates/claim-response-indexed-notifier.test.tsx
new file mode 100644
index 0000000000..b9dc87bd16
--- /dev/null
+++ b/apps/web/core/debates/claim-response-indexed-notifier.test.tsx
@@ -0,0 +1,217 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useClaimResponseIndexedNotifier } from './claim-response-indexed-notifier';
+
+const mocks = vi.hoisted(() => ({ notify: vi.fn() }));
+
+vi.mock('./api', () => ({
+  notifyClaimResponseIndexed: (...args: unknown[]) => mocks.notify(...args),
+}));
+
+describe('useClaimResponseIndexedNotifier', () => {
+  beforeEach(() => {
+    mocks.notify.mockReset();
+    mocks.notify.mockResolvedValue(undefined);
+  });
+
+  it('notifies geo-chat once when a claim response indexing run is confirmed', async () => {
+    const { queryClient, wrapper } = createHarness();
+    const getPrivyIdentityToken = vi.fn();
+    renderHook(() => useClaimResponseIndexedNotifier(true, getPrivyIdentityToken, 'account-1'), { wrapper });
+    const queryKey = ['entity-response-indexing', 'profile-1', 'claim-1', 'space-1', 'veracity'] as const;
+    const indexed = {
+      status: 'indexed',
+      pending: {
+        entityId: 'claim-1',
+        expectedResponse: 'negative',
+        personalSpaceId: 'profile-1',
+        responseKind: 'veracity',
+        spaceId: 'space-1',
+      },
+      runId: 'run-1',
+    } as const;
+
+    act(() => queryClient.setQueryData(queryKey, indexed));
+    await waitFor(() =>
+      expect(mocks.notify).toHaveBeenCalledWith(
+        'space-1',
+        'claim-1',
+        'veracity',
+        false,
+        getPrivyIdentityToken,
+        'account-1',
+        expect.any(AbortSignal)
+      )
+    );
+
+    act(() => queryClient.setQueryData(queryKey, indexed));
+    await Promise.resolve();
+    expect(mocks.notify).toHaveBeenCalledOnce();
+  });
+
+  it('reports cleared responses and ignores curation indexing', async () => {
+    const { queryClient, wrapper } = createHarness();
+    renderHook(() => useClaimResponseIndexedNotifier(true, vi.fn(), 'account-1'), { wrapper });
+
+    act(() => {
+      queryClient.setQueryData(['entity-response-indexing', 'profile-1', 'claim-1', 'space-1', 'stance'], {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: null,
+          personalSpaceId: 'profile-1',
+          responseKind: 'stance',
+          spaceId: 'space-1',
+        },
+        runId: 'run-clear',
+      });
+      queryClient.setQueryData(['entity-response-indexing', 'profile-1', 'entity-1', 'space-1', 'curation'], {
+        status: 'indexed',
+        pending: {
+          entityId: 'entity-1',
+          expectedResponse: 'positive',
+          personalSpaceId: 'profile-1',
+          responseKind: 'curation',
+          spaceId: 'space-1',
+        },
+        runId: 'run-curation',
+      });
+    });
+
+    await waitFor(() => expect(mocks.notify).toHaveBeenCalledOnce());
+    expect(mocks.notify).toHaveBeenCalledWith(
+      'space-1',
+      'claim-1',
+      'stance',
+      null,
+      expect.any(Function),
+      'account-1',
+      expect.any(AbortSignal)
+    );
+  });
+
+  it('falls back to a silent local claim refresh when notification fails', async () => {
+    mocks.notify.mockRejectedValue(new Error('geo-chat unavailable'));
+    const { queryClient, wrapper } = createHarness();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    renderHook(() => useClaimResponseIndexedNotifier(true, vi.fn(), 'account-1'), { wrapper });
+
+    act(() => {
+      queryClient.setQueryData(['entity-response-indexing', 'profile-1', 'claim-1', 'space-1', 'stance'], {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: 'positive',
+          personalSpaceId: 'profile-1',
+          responseKind: 'stance',
+          spaceId: 'space-1',
+        },
+        runId: 'run-failure',
+      });
+    });
+
+    await waitFor(() => expect(mocks.notify).toHaveBeenCalledOnce());
+    await waitFor(() => expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ['debates', 'claims', 'space-1'] }));
+  });
+
+  it('retries an interrupted notification when the same account is re-enabled', async () => {
+    let notificationSignal: AbortSignal | undefined;
+    mocks.notify.mockImplementation((...args: unknown[]) => {
+      notificationSignal = args.at(-1) as AbortSignal;
+      return new Promise((_, reject) => {
+        notificationSignal?.addEventListener(
+          'abort',
+          () => reject(new DOMException('The operation was aborted', 'AbortError')),
+          { once: true }
+        );
+      });
+    });
+    const { queryClient, wrapper } = createHarness();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const getPrivyIdentityToken = vi.fn();
+    const { rerender } = renderHook(
+      ({ enabled }) => useClaimResponseIndexedNotifier(enabled, getPrivyIdentityToken, 'account-1'),
+      {
+        initialProps: { enabled: true },
+        wrapper,
+      }
+    );
+
+    act(() => {
+      queryClient.setQueryData(['entity-response-indexing', 'profile-1', 'claim-1', 'space-1', 'stance'], {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: 'positive',
+          personalSpaceId: 'profile-1',
+          responseKind: 'stance',
+          spaceId: 'space-1',
+        },
+        runId: 'run-cancelled',
+      });
+    });
+
+    await waitFor(() => expect(notificationSignal).toBeDefined());
+    rerender({ enabled: false });
+    await waitFor(() => expect(notificationSignal?.aborted).toBe(true));
+    expect(invalidateQueries).not.toHaveBeenCalled();
+
+    mocks.notify.mockResolvedValue(undefined);
+    rerender({ enabled: true });
+    await waitFor(() => expect(mocks.notify).toHaveBeenCalledTimes(2));
+    expect(invalidateQueries).not.toHaveBeenCalled();
+  });
+
+  it('does not replay an interrupted notification for another account', async () => {
+    let notificationSignal: AbortSignal | undefined;
+    mocks.notify.mockImplementation((...args: unknown[]) => {
+      notificationSignal = args.at(-1) as AbortSignal;
+      return new Promise((_, reject) => {
+        notificationSignal?.addEventListener(
+          'abort',
+          () => reject(new DOMException('The operation was aborted', 'AbortError')),
+          { once: true }
+        );
+      });
+    });
+    const { queryClient, wrapper } = createHarness();
+    const { rerender } = renderHook(({ accountKey }) => useClaimResponseIndexedNotifier(true, vi.fn(), accountKey), {
+      initialProps: { accountKey: 'account-1' },
+      wrapper,
+    });
+
+    act(() => {
+      queryClient.setQueryData(['entity-response-indexing', 'profile-1', 'claim-1', 'space-1', 'stance'], {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: 'positive',
+          personalSpaceId: 'profile-1',
+          responseKind: 'stance',
+          spaceId: 'space-1',
+        },
+        runId: 'run-account-change',
+      });
+    });
+
+    await waitFor(() => expect(notificationSignal).toBeDefined());
+    rerender({ accountKey: 'account-2' });
+    await waitFor(() => expect(notificationSignal?.aborted).toBe(true));
+    expect(mocks.notify).toHaveBeenCalledOnce();
+  });
+});
+
+function createHarness() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return {
+    queryClient,
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  };
+}
diff --git a/apps/web/core/debates/claim-response-indexed-notifier.ts b/apps/web/core/debates/claim-response-indexed-notifier.ts
new file mode 100644
index 0000000000..c5b9ea9280
--- /dev/null
+++ b/apps/web/core/debates/claim-response-indexed-notifier.ts
@@ -0,0 +1,118 @@
+'use client';
+
+import { useQueryClient } from '@tanstack/react-query';
+
+import * as React from 'react';
+
+import type { EntityResponseIndexingState } from '~/core/hooks/use-entity-vote';
+
+import { type DebateResponseKind, type GetPrivyIdentityToken, notifyClaimResponseIndexed } from './api';
+
+const MAX_NOTIFIED_RUNS = 256;
+type IndexedClaimResponse = NonNullable<ReturnType<typeof claimResponseIndexedEvent>>;
+type InterruptedNotification = {
+  accountKey: string;
+  notificationKey: string;
+  response: IndexedClaimResponse;
+};
+
+export function claimResponseIndexedEvent(queryKey: readonly unknown[], data: unknown) {
+  const [scope, , entityId, spaceId, responseKind] = queryKey;
+  const indexingState = data as EntityResponseIndexingState | undefined;
+  if (
+    scope !== 'entity-response-indexing' ||
+    indexingState?.status !== 'indexed' ||
+    !indexingState.pending ||
+    (responseKind !== 'stance' && responseKind !== 'veracity')
+  ) {
+    return null;
+  }
+  return {
+    entityId: String(entityId),
+    position:
+      indexingState.pending.expectedResponse === null ? null : indexingState.pending.expectedResponse === 'positive',
+    responseKind: responseKind as DebateResponseKind,
+    runId: indexingState.runId,
+    spaceId: String(spaceId),
+  };
+}
+
+export function useClaimResponseIndexedNotifier(
+  enabled: boolean,
+  getPrivyIdentityToken: GetPrivyIdentityToken,
+  accountKey: string | null
+) {
+  const queryClient = useQueryClient();
+  const notifiedRuns = React.useRef(new Set<string>());
+  const notifiedRunOrder = React.useRef<string[]>([]);
+  const interruptedNotifications = React.useRef(new Map<string, InterruptedNotification>());
+
+  React.useEffect(() => {
+    if (!enabled || !accountKey) return;
+
+    const notificationControllers = new Map<AbortController, InterruptedNotification>();
+
+    const forgetNotification = (notificationKey: string) => {
+      notifiedRuns.current.delete(notificationKey);
+      notifiedRunOrder.current = notifiedRunOrder.current.filter(key => key !== notificationKey);
+    };
+
+    const startNotification = (notificationKey: string, response: IndexedClaimResponse) => {
+      if (notifiedRuns.current.has(notificationKey)) return;
+
+      notifiedRuns.current.add(notificationKey);
+      notifiedRunOrder.current.push(notificationKey);
+      if (notifiedRunOrder.current.length > MAX_NOTIFIED_RUNS) {
+        const expired = notifiedRunOrder.current.shift();
+        if (expired) notifiedRuns.current.delete(expired);
+      }
+
+      const controller = new AbortController();
+      notificationControllers.set(controller, { accountKey, notificationKey, response });
+      void notifyClaimResponseIndexed(
+        response.spaceId,
+        response.entityId,
+        response.responseKind,
+        response.position,
+        getPrivyIdentityToken,
+        accountKey,
+        controller.signal
+      )
+        .catch(error => {
+          if (isAbortError(error)) return;
+          return queryClient.invalidateQueries({ queryKey: ['debates', 'claims', response.spaceId] });
+        })
+        .finally(() => notificationControllers.delete(controller));
+    };
+
+    const unsubscribe = queryClient.getQueryCache().subscribe(event => {
+      if (event.type !== 'updated' || event.action.type !== 'success') return;
+      const response = claimResponseIndexedEvent(event.query.queryKey, event.query.state.data);
+      if (!response) return;
+      startNotification(`${event.query.queryHash}:${response.runId}`, response);
+    });
+
+    for (const [notificationKey, interrupted] of interruptedNotifications.current) {
+      interruptedNotifications.current.delete(notificationKey);
+      if (interrupted.accountKey === accountKey) {
+        startNotification(notificationKey, interrupted.response);
+      } else {
+        forgetNotification(notificationKey);
+      }
+    }
+
+    return () => {
+      unsubscribe();
+      for (const [controller, interrupted] of notificationControllers) {
+        interruptedNotifications.current.set(interrupted.notificationKey, interrupted);
+        forgetNotification(interrupted.notificationKey);
+        controller.abort();
+      }
+      notificationControllers.clear();
+    };
+  }, [accountKey, enabled, getPrivyIdentityToken, queryClient]);
+}
+
+function isAbortError(error: unknown) {
+  return error instanceof DOMException && error.name === 'AbortError';
+}
diff --git a/apps/web/core/debates/debate-coordinator.test.tsx b/apps/web/core/debates/debate-coordinator.test.tsx
index b5d65557ff..c10fe7f8d0 100644
--- a/apps/web/core/debates/debate-coordinator.test.tsx
+++ b/apps/web/core/debates/debate-coordinator.test.tsx
@@ -56,6 +56,10 @@ vi.mock('./debate-gateway', () => ({
   useDebateGateway: () => ({ status: mocks.gatewayPaused ? 'degraded' : 'ready', paused: mocks.gatewayPaused }),
 }));
 
+vi.mock('./claim-response-indexed-notifier', () => ({
+  useClaimResponseIndexedNotifier: vi.fn(),
+}));
+
 vi.mock('~/core/state/feature-flags', () => ({
   useDebatesEnabled: () => true,
 }));
@@ -743,6 +747,7 @@ function activityWithMatch(): DebateActivity {
     match: {
       id: 'match-1',
       status: 'pending',
+      response_kind: null,
       claim: {
         id: 'claim-1',
         space_id: 'space-1',
diff --git a/apps/web/core/debates/debate-coordinator.tsx b/apps/web/core/debates/debate-coordinator.tsx
index 2297d6e4b4..a8bf919ed6 100644
--- a/apps/web/core/debates/debate-coordinator.tsx
+++ b/apps/web/core/debates/debate-coordinator.tsx
@@ -12,8 +12,9 @@ import { Spinner } from '~/design-system/spinner';
 import { Text } from '~/design-system/text';
 
 import { type DebateMatch, type DebateSharePrompt, getCurrentGeoChatUserId } from './api';
-import { DebateChallengeDialog } from './debate-challenge-dialog';
+import { useClaimResponseIndexedNotifier } from './claim-response-indexed-notifier';
 import { useDebateAttention } from './debate-attention';
+import { DebateChallengeDialog } from './debate-challenge-dialog';
 import { useDebateGateway } from './debate-gateway';
 import {
   clearDebateMatchTabOwnership,
@@ -49,6 +50,11 @@ export function DebateCoordinator() {
     geoChatAuth.accountKey,
     debateAttention
   );
+  useClaimResponseIndexedNotifier(
+    isDebatesEnabled && geoChatAuth.ready && geoChatAuth.authenticated,
+    geoChatAuth.getPrivyIdentityToken,
+    geoChatAuth.accountKey
+  );
   const activityQuery = useDebateActivity(isDebatesEnabled);
   const currentUserId = getCurrentGeoChatUserId();
   const activity = activityQuery.data ?? null;
diff --git a/apps/web/core/debates/debate-entity-response-controls.test.tsx b/apps/web/core/debates/debate-entity-response-controls.test.tsx
new file mode 100644
index 0000000000..c755e4ce22
--- /dev/null
+++ b/apps/web/core/debates/debate-entity-response-controls.test.tsx
@@ -0,0 +1,28 @@
+import '@testing-library/jest-dom/vitest';
+import { cleanup, render, screen } from '@testing-library/react';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { DebateEntityResponseControls } from './debate-entity-response-controls';
+
+vi.mock('~/partials/entity-page/entity-vote-buttons', () => ({
+  EntityVoteButtons: ({ responseKind }: { responseKind?: 'stance' | 'veracity' | null }) => (
+    <span>{responseKind ?? 'unavailable'}</span>
+  ),
+}));
+
+afterEach(cleanup);
+
+describe('DebateEntityResponseControls', () => {
+  it('passes the backend response kind to the shared response controls', () => {
+    render(<DebateEntityResponseControls entityId="claim-1" spaceId="space-1" responseKind="veracity" />);
+
+    expect(screen.getByText('veracity')).toBeInTheDocument();
+  });
+
+  it('preserves an unavailable backend response kind instead of inferring curation', () => {
+    render(<DebateEntityResponseControls entityId="claim-1" spaceId="space-1" responseKind={null} />);
+
+    expect(screen.getByText('unavailable')).toBeInTheDocument();
+  });
+});
diff --git a/apps/web/core/debates/debate-entity-response-controls.tsx b/apps/web/core/debates/debate-entity-response-controls.tsx
new file mode 100644
index 0000000000..e56a8a7a5b
--- /dev/null
+++ b/apps/web/core/debates/debate-entity-response-controls.tsx
@@ -0,0 +1,22 @@
+import { EntityVoteButtons } from '~/partials/entity-page/entity-vote-buttons';
+
+import type { DebateResponseKind } from './api';
+
+export function DebateEntityResponseControls({
+  entityId,
+  spaceId,
+  responseKind,
+}: {
+  entityId: string;
+  spaceId: string;
+  responseKind: DebateResponseKind | null;
+}) {
+  return (
+    <EntityVoteButtons
+      entityId={entityId}
+      spaceId={spaceId}
+      responseKind={responseKind}
+      claimResponderAvatarsPosition="trailing"
+    />
+  );
+}
diff --git a/apps/web/core/debates/debate-gateway.test.ts b/apps/web/core/debates/debate-gateway.test.ts
index 6a2cebeb57..c680c2cdc2 100644
--- a/apps/web/core/debates/debate-gateway.test.ts
+++ b/apps/web/core/debates/debate-gateway.test.ts
@@ -1,4 +1,4 @@
-import { QueryClient } from '@tanstack/react-query';
+import { QueryClient, QueryObserver } from '@tanstack/react-query';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -150,7 +150,7 @@ describe('DebateGatewayClient', () => {
     sockets[0]!.open();
     sockets[0]!.receive('READY', readyPayload([]));
     await flushInvalidations();
-    expectInvalidated(invalidateQueries, { queryKey: ['debates'], refetchType: 'active' });
+    expectBroadInvalidated(invalidateQueries);
     invalidateQueries.mockClear();
 
     const event = {
@@ -231,6 +231,10 @@ describe('DebateGatewayClient', () => {
   it('filters claim invalidations to active claim queries that intersect the event', async () => {
     queryClient.setQueryData(['debates', 'claims', 'space-1', ['claim-1']], {});
     queryClient.setQueryData(['debates', 'claims', 'space-1', ['claim-2']], {});
+    queryClient.setQueryData(['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']], new Map());
+    queryClient.setQueryData(['claim-response-summaries', 'profile-1', 'space-1', ['claim-2:veracity']], new Map());
+    queryClient.setQueryData(['claim-response-summary-data', 'profile-1', 'space-1', ['claim-2:veracity']], new Map());
+    queryClient.setQueryData(['claim-response-summaries', 'profile-1', 'space-2', ['claim-2:veracity']], new Map());
     const refetchQueries = vi.spyOn(queryClient, 'refetchQueries').mockResolvedValue();
 
     client.start(
@@ -259,9 +263,156 @@ describe('DebateGatewayClient', () => {
     expect(
       predicate!(queryClient.getQueryCache().find({ queryKey: ['debates', 'claims', 'space-1', ['claim-2']] })!)
     ).toBe(true);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']] })!
+      )
+    ).toBe(false);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summaries', 'profile-1', 'space-1', ['claim-2:veracity']] })!
+      )
+    ).toBe(true);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summary-data', 'profile-1', 'space-1', ['claim-2:veracity']] })!
+      )
+    ).toBe(true);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summaries', 'profile-1', 'space-2', ['claim-2:veracity']] })!
+      )
+    ).toBe(false);
     expect(refetchQueries).not.toHaveBeenCalled();
   });
 
+  it('coalesces adjacent claim events into one active summary-data refresh', async () => {
+    client.start(
+      vi.fn(async () => 'privy-token'),
+      'user-a'
+    );
+    await vi.runAllTicks();
+    sockets[0]!.open();
+    sockets[0]!.receive('READY', readyPayload([]));
+    await flushInvalidations();
+    invalidateQueries.mockRestore();
+
+    const responseTargets = ['claim-1:stance', 'claim-2:veracity'];
+    const summaryDataKey = ['claim-response-summary-data', 'profile-1', 'space-1', responseTargets] as const;
+    const responseBatchKey = ['claim-response-summaries', 'profile-1', 'space-1', responseTargets] as const;
+    const fetchSummaryData = vi.fn(async () => new Map([['claim-2:veracity', { negative: 1 }]]));
+    const observer = new QueryObserver(queryClient, {
+      queryKey: responseBatchKey,
+      queryFn: () =>
+        queryClient.fetchQuery({
+          queryKey: summaryDataKey,
+          queryFn: fetchSummaryData,
+          staleTime: 30_000,
+        }),
+      staleTime: 30_000,
+    });
+    const unsubscribe = observer.subscribe(() => undefined);
+    await observer.refetch();
+    expect(fetchSummaryData).toHaveBeenCalledOnce();
+
+    sockets[0]!.receive('EVENT', {
+      event_id: 'event-response-summary',
+      event_type: 'debate.claims_changed',
+      payload: { space_id: 'space-1', claim_entity_ids: ['claim-2'] },
+    });
+    sockets[0]!.receive('EVENT', {
+      event_id: 'event-response-summary-adjacent',
+      event_type: 'debate.claims_changed',
+      payload: { space_id: 'space-1', claim_entity_ids: ['claim-1'] },
+    });
+    await flushInvalidations();
+    await vi.runAllTicks();
+
+    expect(fetchSummaryData).toHaveBeenCalledTimes(2);
+    unsubscribe();
+  });
+
+  it('broadly reconciles debate and active claim response batches', async () => {
+    queryClient.setQueryData(['debates', 'claims', 'space-1', ['claim-1']], {});
+    queryClient.setQueryData(['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']], new Map());
+    queryClient.setQueryData(['claim-response-summary-data', 'profile-1', 'space-1', ['claim-1:stance']], new Map());
+    queryClient.setQueryData(['unrelated', 'space-1'], {});
+
+    client.start(
+      vi.fn(async () => 'privy-token'),
+      'user-a'
+    );
+    await vi.runAllTicks();
+    sockets[0]!.open();
+    sockets[0]!.receive('READY', readyPayload([]));
+    await flushInvalidations();
+
+    type InvalidationFilters = NonNullable<Parameters<QueryClient['invalidateQueries']>[0]>;
+    const invalidationCalls = invalidateQueries.mock.calls as unknown as Array<[InvalidationFilters]>;
+    const predicate = invalidationCalls.map(call => call[0]).find(filters => 'predicate' in filters)?.predicate;
+    expect(predicate).toBeTypeOf('function');
+    expect(
+      predicate!(queryClient.getQueryCache().find({ queryKey: ['debates', 'claims', 'space-1', ['claim-1']] })!)
+    ).toBe(true);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']] })!
+      )
+    ).toBe(true);
+    expect(
+      predicate!(
+        queryClient
+          .getQueryCache()
+          .find({ queryKey: ['claim-response-summary-data', 'profile-1', 'space-1', ['claim-1:stance']] })!
+      )
+    ).toBe(true);
+    expect(predicate!(queryClient.getQueryCache().find({ queryKey: ['unrelated', 'space-1'] })!)).toBe(false);
+  });
+
+  it('refetches an active response batch during broad reconnect reconciliation', async () => {
+    invalidateQueries.mockRestore();
+    const responseTargets = ['claim-1:stance'];
+    const summaryDataKey = ['claim-response-summary-data', 'profile-1', 'space-1', responseTargets] as const;
+    const responseBatchKey = ['claim-response-summaries', 'profile-1', 'space-1', responseTargets] as const;
+    const fetchSummaryData = vi.fn(async () => new Map([['claim-1:stance', { positive: 1 }]]));
+    const observer = new QueryObserver(queryClient, {
+      queryKey: responseBatchKey,
+      queryFn: () =>
+        queryClient.fetchQuery({
+          queryKey: summaryDataKey,
+          queryFn: fetchSummaryData,
+          staleTime: 30_000,
+        }),
+      staleTime: 30_000,
+    });
+    const unsubscribe = observer.subscribe(() => undefined);
+    await observer.refetch();
+    expect(fetchSummaryData).toHaveBeenCalledOnce();
+
+    client.start(
+      vi.fn(async () => 'privy-token'),
+      'user-a'
+    );
+    await vi.runAllTicks();
+    sockets[0]!.open();
+    sockets[0]!.receive('READY', readyPayload([]));
+    await flushInvalidations();
+    await vi.runAllTicks();
+
+    expect(fetchSummaryData).toHaveBeenCalledTimes(2);
+    unsubscribe();
+  });
+
   it('sends presence heartbeats and reconnects after two missed acknowledgements', async () => {
     client.start(
       vi.fn(async () => 'privy-token'),
@@ -373,12 +524,12 @@ describe('DebateGatewayClient', () => {
     sockets[1]!.open();
     sockets[1]!.receive('READY', readyPayload([]));
     await flushInvalidations();
-    expectInvalidated(invalidateQueries, { queryKey: ['debates'], refetchType: 'active' });
+    expectBroadInvalidated(invalidateQueries);
 
     invalidateQueries.mockClear();
     sockets[1]!.receive('ERROR', { code: 'events_lagged', message: 'events skipped' });
     await flushInvalidations();
-    expectInvalidated(invalidateQueries, { queryKey: ['debates'], refetchType: 'active' });
+    expectBroadInvalidated(invalidateQueries);
   });
 
   it('abandons a socket that never completes the protocol handshake', async () => {
@@ -426,7 +577,7 @@ describe('DebateGatewayClient', () => {
     sockets[0]!.receive('READY', readyPayload([]));
     await flushInvalidations();
 
-    expect(cancelQueries).toHaveBeenCalledWith({ queryKey: ['debates'], refetchType: 'active' });
+    expect(cancelQueries).toHaveBeenCalledWith({ predicate: expect.any(Function), refetchType: 'active' });
     expect(cancelQueries.mock.invocationCallOrder[0]).toBeLessThan(invalidateQueries.mock.invocationCallOrder[0]!);
   });
 
@@ -621,3 +772,10 @@ async function flushInvalidations() {
 function expectInvalidated(invalidateQueries: ReturnType<typeof vi.spyOn>, filters: unknown) {
   expect(invalidateQueries.mock.calls).toContainEqual([filters, { throwOnError: true }]);
 }
+
+function expectBroadInvalidated(invalidateQueries: ReturnType<typeof vi.spyOn>) {
+  expect(invalidateQueries).toHaveBeenCalledWith(
+    { predicate: expect.any(Function), refetchType: 'active' },
+    { throwOnError: true }
+  );
+}
diff --git a/apps/web/core/debates/debate-gateway.ts b/apps/web/core/debates/debate-gateway.ts
index 795606bdba..ac90e5eecb 100644
--- a/apps/web/core/debates/debate-gateway.ts
+++ b/apps/web/core/debates/debate-gateway.ts
@@ -5,6 +5,10 @@ import type { QueryClient, QueryKey } from '@tanstack/react-query';
 import * as React from 'react';
 
 import { queryClient } from '~/core/query-client';
+import {
+  claimResponseTargetKey,
+  isClaimResponseSummaryQueryKey,
+} from '~/core/responses/claim-response-summary-query-keys';
 
 import { type GeoChatSession, type GetPrivyIdentityToken, getGeoChatApiBaseUrl, getGeoChatSession } from './api';
 
@@ -83,6 +87,7 @@ export class DebateGatewayClient {
   private readonly recentEventIds = new Set<string>();
   private readonly recentEventIdOrder: string[] = [];
   private readonly pendingInvalidations = new Map<string, InvalidationFilters>();
+  private readonly pendingChangedClaimsBySpace = new Map<string, Set<string>>();
 
   private snapshot: DebateGatewaySnapshot = { status: 'idle', paused: false };
   private getPrivyIdentityToken: GetPrivyIdentityToken | null = null;
@@ -154,6 +159,7 @@ export class DebateGatewayClient {
     this.sentScopes.clear();
     this.confirmedScopes.clear();
     this.pendingInvalidations.clear();
+    this.pendingChangedClaimsBySpace.clear();
     if (accountKey) this.queryClient.removeQueries({ queryKey: ['debates'] });
     this.setSnapshot({ status: 'idle', paused: false });
   }
@@ -367,7 +373,13 @@ export class DebateGatewayClient {
   }
 
   private queueBroadReconcile() {
-    this.queueInvalidation(BROAD_INVALIDATION_KEY, { queryKey: ['debates'], refetchType: 'active' });
+    this.queueInvalidation(BROAD_INVALIDATION_KEY, {
+      predicate: query => {
+        const root = query.queryKey[0];
+        return root === 'debates' || isClaimResponseSummaryQueryKey(query.queryKey);
+      },
+      refetchType: 'active',
+    });
   }
 
   /** A profile's `can_challenge` folds in the viewer's own activity, so it goes stale with it. */
@@ -388,17 +400,32 @@ export class DebateGatewayClient {
       this.queueQuery(['debates', 'claims', spaceId]);
       return;
     }
-    const changedClaims = new Set(claimEntityIds);
-    this.queueInvalidation(`claims:${spaceId}:${claimEntityIds.slice().sort().join(',')}`, {
+    let changedClaims = this.pendingChangedClaimsBySpace.get(spaceId);
+    if (!changedClaims) {
+      changedClaims = new Set();
+      this.pendingChangedClaimsBySpace.set(spaceId, changedClaims);
+    }
+    for (const claimEntityId of claimEntityIds) changedClaims.add(claimEntityId);
+    const changedResponseTargets = new Set(
+      [...changedClaims].flatMap(entityId =>
+        (['stance', 'veracity'] as const).map(responseKind => claimResponseTargetKey({ entityId, responseKind }))
+      )
+    );
+    this.queueInvalidation(`claims:${spaceId}`, {
       predicate: query => {
         const [root, kind, querySpaceId, queryClaimIds] = query.queryKey;
-        return (
+        const isDebateClaimQuery =
           root === 'debates' &&
           kind === 'claims' &&
           querySpaceId === spaceId &&
           Array.isArray(queryClaimIds) &&
-          queryClaimIds.some(claimId => typeof claimId === 'string' && changedClaims.has(claimId))
-        );
+          queryClaimIds.some(claimId => typeof claimId === 'string' && changedClaims.has(claimId));
+        if (isDebateClaimQuery) return true;
+
+        return isClaimResponseSummaryQueryKey(query.queryKey, {
+          spaceId,
+          targetKeys: changedResponseTargets,
+        });
       },
       refetchType: 'active',
     });
@@ -411,6 +438,7 @@ export class DebateGatewayClient {
   private queueInvalidation(key: string, filters: InvalidationFilters) {
     if (key === BROAD_INVALIDATION_KEY) {
       this.pendingInvalidations.clear();
+      this.pendingChangedClaimsBySpace.clear();
     } else if (this.pendingInvalidations.has(BROAD_INVALIDATION_KEY)) {
       return;
     }
@@ -420,6 +448,7 @@ export class DebateGatewayClient {
       this.invalidationTimer = null;
       const invalidations = [...this.pendingInvalidations.values()];
       this.pendingInvalidations.clear();
+      this.pendingChangedClaimsBySpace.clear();
       void this.flushInvalidations(invalidations);
     }, INVALIDATION_COALESCE_MS);
   }
diff --git a/apps/web/core/debates/debate-readiness-intent.ts b/apps/web/core/debates/debate-readiness-intent.ts
new file mode 100644
index 0000000000..732f18ad16
--- /dev/null
+++ b/apps/web/core/debates/debate-readiness-intent.ts
@@ -0,0 +1,73 @@
+'use client';
+
+import { hashKey, useQueryClient } from '@tanstack/react-query';
+
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+
+import type { DebateResponseKind } from './api';
+
+type DebateReadinessIntent = {
+  desiredReady: boolean;
+  confirmedReady: boolean;
+  inFlightReady: boolean | null;
+  expectedPosition: boolean | null;
+  responseRunId: string | null;
+  hasRetried: boolean;
+  refreshing: boolean;
+  error: string | null;
+};
+
+function debateReadinessIntentQueryKey(
+  accountKey: string | null,
+  spaceId: string,
+  claimId: string,
+  responseKind: DebateResponseKind
+) {
+  return ['debates', 'readiness-intent', accountKey, spaceId, claimId, responseKind] as const;
+}
+
+export function useDebateReadinessIntent(
+  accountKey: string | null,
+  spaceId: string,
+  claimId: string,
+  responseKind: DebateResponseKind
+) {
+  const queryClient = useQueryClient();
+  const queryKey = useMemo(
+    () => debateReadinessIntentQueryKey(accountKey, spaceId, claimId, responseKind),
+    [accountKey, claimId, responseKind, spaceId]
+  );
+  const queryHash = useMemo(() => hashKey(queryKey), [queryKey]);
+  const previousQueryKeyRef = useRef(queryKey);
+  const getSnapshot = useCallback(
+    () => queryClient.getQueryData<DebateReadinessIntent>(queryKey) ?? null,
+    [queryClient, queryKey]
+  );
+  const subscribe = useCallback(
+    (onStoreChange: () => void) =>
+      queryClient.getQueryCache().subscribe(event => {
+        if (event.query.queryHash === queryHash) onStoreChange();
+      }),
+    [queryClient, queryHash]
+  );
+
+  useEffect(() => {
+    const previousQueryKey = previousQueryKeyRef.current;
+    if (previousQueryKey !== queryKey) {
+      queryClient.setQueryData(previousQueryKey, null);
+      previousQueryKeyRef.current = queryKey;
+    }
+  }, [queryClient, queryKey]);
+
+  const setIntent = useCallback(
+    (intent: DebateReadinessIntent | null) => queryClient.setQueryData(queryKey, intent),
+    [queryClient, queryKey]
+  );
+  const updateIntent = useCallback(
+    (updater: (current: DebateReadinessIntent | null) => DebateReadinessIntent | null) =>
+      queryClient.setQueryData<DebateReadinessIntent | null>(queryKey, current => updater(current ?? null)),
+    [queryClient, queryKey]
+  );
+
+  return { intent: useSyncExternalStore(subscribe, getSnapshot, getSnapshot), setIntent, updateIntent };
+}
diff --git a/apps/web/core/debates/hooks-query-network.test.tsx b/apps/web/core/debates/hooks-query-network.test.tsx
index 4c3d90a020..ac11878376 100644
--- a/apps/web/core/debates/hooks-query-network.test.tsx
+++ b/apps/web/core/debates/hooks-query-network.test.tsx
@@ -2,25 +2,30 @@ import { renderHook } from '@testing-library/react';
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { GeoChatRequestError } from './api';
 import {
   useCreateDebateChallenge,
   useDebate,
   useDebateActivity,
   useDebateClaims,
   useDebateMedia,
+  useDebateProfile,
   useDebateRematch,
   useDebateRematchClaims,
-  useDebateProfile,
   useDebateSharePrompts,
   useDebateTranscript,
   useSpaceDebates,
 } from './hooks';
-import { GeoChatRequestError } from './api';
 
 const mocks = vi.hoisted(() => ({
   authenticated: true,
   attention: true,
-  queryClient: { invalidateQueries: vi.fn(), setQueryData: vi.fn() },
+  queryCache: { subscribe: vi.fn(() => vi.fn()) },
+  queryClient: {
+    getQueryCache: vi.fn(() => mocks.queryCache),
+    invalidateQueries: vi.fn(),
+    setQueryData: vi.fn(),
+  },
   queryRefetch: vi.fn(),
   useMutation: vi.fn((options: unknown) => options),
   useQuery: vi.fn((options: unknown) => ({ options, refetch: mocks.queryRefetch })),
@@ -55,6 +60,8 @@ beforeEach(() => {
   mocks.authenticated = true;
   mocks.attention = true;
   mocks.queryClient.invalidateQueries.mockClear();
+  mocks.queryClient.getQueryCache.mockClear();
+  mocks.queryCache.subscribe.mockClear();
   mocks.queryClient.setQueryData.mockClear();
   mocks.queryRefetch.mockClear();
   mocks.useMutation.mockClear();
@@ -103,10 +110,9 @@ describe('debate query network ownership', () => {
       onError(error: Error, request: { recipient_profile_space_id: string }): void;
     };
 
-    mutation.onError(
-      new GeoChatRequestError('Unavailable', 'challenge_unavailable', 400),
-      { recipient_profile_space_id: 'profile-b' }
-    );
+    mutation.onError(new GeoChatRequestError('Unavailable', 'challenge_unavailable', 400), {
+      recipient_profile_space_id: 'profile-b',
+    });
 
     expect(mocks.queryClient.invalidateQueries).toHaveBeenCalledWith({
       queryKey: ['debates', 'account', 'user-a', 'profile', 'profile-b'],
diff --git a/apps/web/core/debates/hooks.test.tsx b/apps/web/core/debates/hooks.test.tsx
index 16bf800f83..d224ec407e 100644
--- a/apps/web/core/debates/hooks.test.tsx
+++ b/apps/web/core/debates/hooks.test.tsx
@@ -6,6 +6,7 @@ import type { ReactNode } from 'react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { setCachedIdentityToken } from '~/core/auth/identity-token';
+import { entityResponseIndexingQueryKey } from '~/core/responses/entity-response';
 
 import { type Debate, type DebateActivity, type DebateRematchSession, GeoChatRequestError } from './api';
 import { DebateCoordinator } from './debate-coordinator';
@@ -16,6 +17,8 @@ import {
   useConsentToDebateRematch,
   useDebate,
   useDebateActivity,
+  useDebateClaims,
+  useDebateRematchClaims,
   useEndDebateTurn,
   useGeoChatAuth,
   useLeaveDebateRematch,
@@ -30,6 +33,8 @@ const mocks = vi.hoisted(() => ({
   consentToDebateRematch: vi.fn(),
   endDebateTurn: vi.fn(),
   leaveDebateRematch: vi.fn(),
+  listDebateClaims: vi.fn(),
+  listDebateRematchClaims: vi.fn(),
   listDebateSharePrompts: vi.fn(),
   markDebateReady: vi.fn(),
   pathname: '/space/space-1/debates/debate-1',
@@ -69,6 +74,8 @@ vi.mock('./api', async importOriginal => {
     consentToDebateRematch: mocks.consentToDebateRematch,
     endDebateTurn: mocks.endDebateTurn,
     leaveDebateRematch: mocks.leaveDebateRematch,
+    listDebateClaims: mocks.listDebateClaims,
+    listDebateRematchClaims: mocks.listDebateRematchClaims,
     listDebateSharePrompts: mocks.listDebateSharePrompts,
     markDebateReady: mocks.markDebateReady,
     updateDebateAvailability: mocks.updateDebateAvailability,
@@ -109,12 +116,16 @@ describe('useGeoChatAuth', () => {
     mocks.consentToDebateRematch.mockReset();
     mocks.endDebateTurn.mockReset();
     mocks.leaveDebateRematch.mockReset();
+    mocks.listDebateClaims.mockReset();
+    mocks.listDebateRematchClaims.mockReset();
     mocks.listDebateSharePrompts.mockReset();
     mocks.markDebateReady.mockReset();
     mocks.push.mockReset();
     mocks.back.mockReset();
     mocks.pathname = '/space/space-1/debates/debate-1';
     mocks.updateDebateAvailability.mockReset();
+    mocks.listDebateClaims.mockResolvedValue({ claims: [] });
+    mocks.listDebateRematchClaims.mockResolvedValue({ claims: [], excluded_claim_ids: [] });
     mocks.listDebateSharePrompts.mockResolvedValue({ prompts: [] });
     setCachedIdentityToken(null);
   });
@@ -179,6 +190,76 @@ describe('useGeoChatAuth', () => {
     expect(mocks.getIdentityToken).toHaveBeenCalledTimes(1);
   });
 
+  it('leaves indexed-response claim refreshes to the gateway notification path', async () => {
+    mocks.identityToken.mockReturnValue(null);
+    mocks.getIdentityToken.mockResolvedValue(null);
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+
+    renderHook(() => useDebateClaims('space-1', ['claim-1'], true), { wrapper });
+    await waitFor(() => expect(mocks.listDebateClaims).toHaveBeenCalled());
+    invalidateQueries.mockClear();
+
+    act(() => {
+      queryClient.setQueryData(['user-entity-response', 'profile-1', 'claim-1', 'space-1', 0, 'stance'], 'positive');
+    });
+    expect(invalidateQueries).not.toHaveBeenCalled();
+
+    act(() => {
+      queryClient.setQueryData(entityResponseIndexingQueryKey('profile-1', 'claim-1', 'space-1', 'stance'), {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: 'positive',
+          personalSpaceId: 'profile-1',
+          responseKind: 'stance',
+          spaceId: 'space-1',
+        },
+        runId: 'run-1',
+      });
+    });
+
+    await Promise.resolve();
+    expect(invalidateQueries).not.toHaveBeenCalled();
+  });
+
+  it('refetches rematch snapshots when response reconciliation is fully indexed', async () => {
+    mocks.identityToken.mockReturnValue(null);
+    mocks.getIdentityToken.mockResolvedValue(null);
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+
+    renderHook(() => useDebateRematchClaims('rematch-1', ['claim-1']), { wrapper });
+    await waitFor(() => expect(mocks.listDebateRematchClaims).toHaveBeenCalled());
+    invalidateQueries.mockClear();
+
+    act(() => {
+      queryClient.setQueryData(entityResponseIndexingQueryKey('profile-1', 'claim-1', 'space-1', 'veracity'), {
+        status: 'indexed',
+        pending: {
+          entityId: 'claim-1',
+          expectedResponse: 'negative',
+          personalSpaceId: 'profile-1',
+          responseKind: 'veracity',
+          spaceId: 'space-1',
+        },
+        runId: 'run-1',
+      });
+    });
+
+    await waitFor(() =>
+      expect(invalidateQueries).toHaveBeenCalledWith({
+        queryKey: ['debates', 'account', 'user-a', 'rematch', 'rematch-1', 'claims'],
+      })
+    );
+  });
+
   // A `users/me` sent before logout can resolve after it. Writing that result back would
   // repopulate the cache with the signed-out user's token, and nothing would clear it again
   // until it expired, because Privy's reactive token just stays null.
diff --git a/apps/web/core/debates/hooks.ts b/apps/web/core/debates/hooks.ts
index 3305686a29..2f3b415590 100644
--- a/apps/web/core/debates/hooks.ts
+++ b/apps/web/core/debates/hooks.ts
@@ -7,8 +7,6 @@ import * as React from 'react';
 
 import { getCachedIdentityToken, useIdentityTokenSync } from '~/core/auth/identity-token';
 
-import { useDebateAttention } from './debate-attention';
-
 import {
   type Debate,
   type DebateActivity,
@@ -16,7 +14,6 @@ import {
   type DebateMediaProcessRequest,
   type DebateMediaResponse,
   GeoChatRequestError,
-  type JoinDebateQueueRequest,
   type LocalRecordingCompleteRequest,
   type LocalRecordingUploadRequest,
   type TranscriptFormat,
@@ -56,9 +53,9 @@ import {
   requestDebateMediaProcessing,
   retryDebatePhaseBoundaryRequest,
   updateDebateAvailability,
-  updateDebatePreference,
-  updateDebateRematchPosition,
 } from './api';
+import { claimResponseIndexedEvent } from './claim-response-indexed-notifier';
+import { useDebateAttention } from './debate-attention';
 import { useDebateGatewayScope } from './debate-gateway';
 import { hasProcessedVideo } from './playback-utils';
 
@@ -124,8 +121,8 @@ export function useJoinDebateQueue(spaceId: string) {
   const { accountKey, getPrivyIdentityToken } = useGeoChatAuth();
 
   return useMutation({
-    mutationFn: ({ claimId, request }: { claimId: string; request: JoinDebateQueueRequest }) =>
-      joinDebateQueue(spaceId, claimId, request, getPrivyIdentityToken, accountKey),
+    mutationFn: ({ claimId }: { claimId: string }) =>
+      joinDebateQueue(spaceId, claimId, getPrivyIdentityToken, accountKey),
     onSuccess: () => {
       void queryClient.invalidateQueries({ queryKey: ['debates'] });
     },
@@ -145,17 +142,6 @@ export function useLeaveDebateQueue(spaceId: string) {
   });
 }
 
-export function useUpdateDebatePreference(spaceId: string) {
-  const queryClient = useQueryClient();
-  const { accountKey, getPrivyIdentityToken } = useGeoChatAuth();
-
-  return useMutation({
-    mutationFn: ({ claimId, position }: { claimId: string; position: boolean }) =>
-      updateDebatePreference(spaceId, claimId, { position }, getPrivyIdentityToken, accountKey),
-    onSuccess: () => void queryClient.invalidateQueries({ queryKey: ['debates'] }),
-  });
-}
-
 export function useDebateActivity(enabled = true) {
   const queryClient = useQueryClient();
   const { accountKey, authenticated, getPrivyIdentityToken } = useGeoChatAuth();
@@ -432,8 +418,28 @@ export function useLeaveDebateRematch(sessionId: string) {
 }
 
 export function useDebateRematchClaims(sessionId: string, claimIds: string[] = [], enabled = true) {
+  const queryClient = useQueryClient();
   const { accountKey, getPrivyIdentityToken } = useGeoChatAuth();
 
+  React.useEffect(
+    function refetchRematchClaimsAfterIndexedResponse() {
+      if (!enabled || !sessionId) return;
+
+      return queryClient.getQueryCache().subscribe(event => {
+        if (event.type !== 'updated' || event.action.type !== 'success') return;
+        const response = claimResponseIndexedEvent(event.query.queryKey, event.query.state.data);
+        if (!response || (claimIds.length > 0 && !claimIds.includes(response.entityId))) {
+          return;
+        }
+
+        void queryClient.invalidateQueries({
+          queryKey: ['debates', 'account', accountKey, 'rematch', sessionId, 'claims'],
+        });
+      });
+    },
+    [accountKey, claimIds, enabled, queryClient, sessionId]
+  );
+
   return useQuery({
     ...debateQueryNetworkOptions,
     queryKey: debateQueryKeys.rematchClaims(accountKey, sessionId, claimIds),
@@ -442,20 +448,6 @@ export function useDebateRematchClaims(sessionId: string, claimIds: string[] = [
   });
 }
 
-export function useUpdateDebateRematchPosition(sessionId: string) {
-  const queryClient = useQueryClient();
-  const { accountKey, getPrivyIdentityToken } = useGeoChatAuth();
-
-  return useMutation({
-    mutationFn: ({ claimId, position, sourceSpaceId }: { claimId: string; position: boolean; sourceSpaceId: string }) =>
-      updateDebateRematchPosition(sessionId, claimId, position, sourceSpaceId, getPrivyIdentityToken, accountKey),
-    onSuccess: () =>
-      void queryClient.invalidateQueries({
-        queryKey: ['debates', 'account', accountKey, 'rematch', sessionId, 'claims'],
-      }),
-  });
-}
-
 export function useCreateDebateRematchRequest(sessionId: string) {
   const queryClient = useQueryClient();
   const { accountKey, getPrivyIdentityToken } = useGeoChatAuth();
diff --git a/apps/web/core/debates/match-prompt.test.tsx b/apps/web/core/debates/match-prompt.test.tsx
index 9241b955d7..9011c13c13 100644
--- a/apps/web/core/debates/match-prompt.test.tsx
+++ b/apps/web/core/debates/match-prompt.test.tsx
@@ -777,6 +777,7 @@ function match(): DebateMatch {
   return {
     id: 'match-1',
     status: 'pending',
+    response_kind: null,
     claim: {
       id: 'claim-1',
       space_id: 'space-1',
@@ -831,6 +832,7 @@ function debate(): Debate {
       description: null,
     },
     status: 'ready',
+    response_kind: null,
     room_name: 'geo-debate-debate-1',
     first_participant_slot: 1,
     current_turn_index: 0,
diff --git a/apps/web/core/debates/response-derived-contract.test.ts b/apps/web/core/debates/response-derived-contract.test.ts
new file mode 100644
index 0000000000..9cd4d845b9
--- /dev/null
+++ b/apps/web/core/debates/response-derived-contract.test.ts
@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+
+import * as debateApi from './api';
+import * as debateHooks from './hooks';
+
+describe('response-derived debate contract', () => {
+  it('does not expose deprecated position-update endpoints or hooks', () => {
+    expect(debateApi).not.toHaveProperty('updateDebatePreference');
+    expect(debateApi).not.toHaveProperty('updateDebateRematchPosition');
+    expect(debateHooks).not.toHaveProperty('useUpdateDebatePreference');
+    expect(debateHooks).not.toHaveProperty('useUpdateDebateRematchPosition');
+  });
+});
diff --git a/apps/web/core/gql/gql.ts b/apps/web/core/gql/gql.ts
index 9b5881e6d0..00e83f3fad 100644
--- a/apps/web/core/gql/gql.ts
+++ b/apps/web/core/gql/gql.ts
@@ -51,9 +51,10 @@ type Documents = {
     "\n  query ImportNameValues($propertyId: UUID!, $texts: [String!], $first: Int, $entityFilter: EntityFilter) {\n    values(\n      condition: { propertyId: $propertyId }\n      filter: { text: { inInsensitive: $texts }, entity: $entityFilter }\n      first: $first\n    ) {\n      id\n      text\n      spaceId\n      entity {\n        id\n        name\n        typeIds\n        backlinks {\n          totalCount\n        }\n        relations {\n          totalCount\n        }\n      }\n    }\n  }\n": typeof types.ImportNameValuesDocument,
     "\n  query EntityTiebreakerBatch($filter: EntityFilter) {\n    entities(filter: $filter) {\n      id\n      createdAt\n      backlinks {\n        totalCount\n      }\n      relations {\n        totalCount\n      }\n      values {\n        totalCount\n      }\n    }\n  }\n": typeof types.EntityTiebreakerBatchDocument,
     "\n  query RelationEntityMinimal($id: UUID!, $spaceId: UUID) {\n    relation(id: $id) {\n      id\n      entity {\n        id\n        name\n        description\n        spaceIds\n\n        types {\n          id\n          name\n        }\n\n        allValuesList: valuesList(first: 1000) {\n          spaceId\n          propertyId\n        }\n\n        allRelationsList: relationsList(first: 1000) {\n          spaceId\n        }\n\n        valuesList(first: 1000, filter: { spaceId: { is: $spaceId } }) {\n          spaceId\n          property {\n            id\n            name\n            dataTypeId\n            dataTypeName\n            renderableTypeId\n            renderableTypeName\n            format\n          }\n          text\n          integer\n          float\n          point\n          boolean\n          time\n          language\n          unit\n          datetime\n          date\n          decimal\n          schedule\n        }\n        relationsList(first: 1000) {\n          verified\n          toSpaceId\n          position\n          spaceId\n          id\n          entityId\n          fromEntity {\n            id\n            name\n          }\n          toEntity {\n            ...RelationToEntity\n          }\n          type {\n            id\n            name\n            description\n          }\n        }\n      }\n    }\n  }\n": typeof types.RelationEntityMinimalDocument,
-    "\n  query EntityVoteCount($objectId: UUID!, $objectType: Int!) {\n    votesCountsConnection(condition: { objectId: $objectId, objectType: $objectType }) {\n      nodes {\n        spaceId\n        upvotes\n        downvotes\n      }\n    }\n  }\n": typeof types.EntityVoteCountDocument,
-    "\n  query UserEntityVote($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n    ) {\n      voteType\n    }\n  }\n": typeof types.UserEntityVoteDocument,
-    "\n  query EntityVoters($objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId }) {\n      userId\n      voteType\n    }\n  }\n": typeof types.EntityVotersDocument,
+    "\n  query EntityResponseCounts($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      positive\n      negative\n      voteKind\n    }\n  }\n": typeof types.EntityResponseCountsDocument,
+    "\n  query UserEntityResponse($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      voteType\n    }\n  }\n": typeof types.UserEntityResponseDocument,
+    "\n  query EntityResponders($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId, voteKind: $voteKind }) {\n      userId\n      voteType\n    }\n  }\n": typeof types.EntityRespondersDocument,
+    "\n  query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!) {\n    userVotes(filter: $filter, first: $first, offset: $offset, orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]) {\n      userId\n      objectId\n      voteType\n      voteKind\n    }\n  }\n": typeof types.ClaimResponseSummariesDocument,
     "\n  query UserHasEntityVote($userId: UUID!) {\n    userVotes(condition: { userId: $userId }, first: 1) {\n      userId\n    }\n  }\n": typeof types.UserHasEntityVoteDocument,
 };
 const documents: Documents = {
@@ -94,9 +95,10 @@ const documents: Documents = {
     "\n  query ImportNameValues($propertyId: UUID!, $texts: [String!], $first: Int, $entityFilter: EntityFilter) {\n    values(\n      condition: { propertyId: $propertyId }\n      filter: { text: { inInsensitive: $texts }, entity: $entityFilter }\n      first: $first\n    ) {\n      id\n      text\n      spaceId\n      entity {\n        id\n        name\n        typeIds\n        backlinks {\n          totalCount\n        }\n        relations {\n          totalCount\n        }\n      }\n    }\n  }\n": types.ImportNameValuesDocument,
     "\n  query EntityTiebreakerBatch($filter: EntityFilter) {\n    entities(filter: $filter) {\n      id\n      createdAt\n      backlinks {\n        totalCount\n      }\n      relations {\n        totalCount\n      }\n      values {\n        totalCount\n      }\n    }\n  }\n": types.EntityTiebreakerBatchDocument,
     "\n  query RelationEntityMinimal($id: UUID!, $spaceId: UUID) {\n    relation(id: $id) {\n      id\n      entity {\n        id\n        name\n        description\n        spaceIds\n\n        types {\n          id\n          name\n        }\n\n        allValuesList: valuesList(first: 1000) {\n          spaceId\n          propertyId\n        }\n\n        allRelationsList: relationsList(first: 1000) {\n          spaceId\n        }\n\n        valuesList(first: 1000, filter: { spaceId: { is: $spaceId } }) {\n          spaceId\n          property {\n            id\n            name\n            dataTypeId\n            dataTypeName\n            renderableTypeId\n            renderableTypeName\n            format\n          }\n          text\n          integer\n          float\n          point\n          boolean\n          time\n          language\n          unit\n          datetime\n          date\n          decimal\n          schedule\n        }\n        relationsList(first: 1000) {\n          verified\n          toSpaceId\n          position\n          spaceId\n          id\n          entityId\n          fromEntity {\n            id\n            name\n          }\n          toEntity {\n            ...RelationToEntity\n          }\n          type {\n            id\n            name\n            description\n          }\n        }\n      }\n    }\n  }\n": types.RelationEntityMinimalDocument,
-    "\n  query EntityVoteCount($objectId: UUID!, $objectType: Int!) {\n    votesCountsConnection(condition: { objectId: $objectId, objectType: $objectType }) {\n      nodes {\n        spaceId\n        upvotes\n        downvotes\n      }\n    }\n  }\n": types.EntityVoteCountDocument,
-    "\n  query UserEntityVote($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n    ) {\n      voteType\n    }\n  }\n": types.UserEntityVoteDocument,
-    "\n  query EntityVoters($objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId }) {\n      userId\n      voteType\n    }\n  }\n": types.EntityVotersDocument,
+    "\n  query EntityResponseCounts($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      positive\n      negative\n      voteKind\n    }\n  }\n": types.EntityResponseCountsDocument,
+    "\n  query UserEntityResponse($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      voteType\n    }\n  }\n": types.UserEntityResponseDocument,
+    "\n  query EntityResponders($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId, voteKind: $voteKind }) {\n      userId\n      voteType\n    }\n  }\n": types.EntityRespondersDocument,
+    "\n  query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!) {\n    userVotes(filter: $filter, first: $first, offset: $offset, orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]) {\n      userId\n      objectId\n      voteType\n      voteKind\n    }\n  }\n": types.ClaimResponseSummariesDocument,
     "\n  query UserHasEntityVote($userId: UUID!) {\n    userVotes(condition: { userId: $userId }, first: 1) {\n      userId\n    }\n  }\n": types.UserHasEntityVoteDocument,
 };
 
@@ -265,15 +267,19 @@ export function graphql(source: "\n  query RelationEntityMinimal($id: UUID!, $sp
 /**
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
-export function graphql(source: "\n  query EntityVoteCount($objectId: UUID!, $objectType: Int!) {\n    votesCountsConnection(condition: { objectId: $objectId, objectType: $objectType }) {\n      nodes {\n        spaceId\n        upvotes\n        downvotes\n      }\n    }\n  }\n"): (typeof documents)["\n  query EntityVoteCount($objectId: UUID!, $objectType: Int!) {\n    votesCountsConnection(condition: { objectId: $objectId, objectType: $objectType }) {\n      nodes {\n        spaceId\n        upvotes\n        downvotes\n      }\n    }\n  }\n"];
+export function graphql(source: "\n  query EntityResponseCounts($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      positive\n      negative\n      voteKind\n    }\n  }\n"): (typeof documents)["\n  query EntityResponseCounts($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      positive\n      negative\n      voteKind\n    }\n  }\n"];
 /**
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
-export function graphql(source: "\n  query UserEntityVote($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n    ) {\n      voteType\n    }\n  }\n"): (typeof documents)["\n  query UserEntityVote($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n    ) {\n      voteType\n    }\n  }\n"];
+export function graphql(source: "\n  query UserEntityResponse($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      voteType\n    }\n  }\n"): (typeof documents)["\n  query UserEntityResponse($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind(\n      userId: $userId\n      objectId: $objectId\n      objectType: $objectType\n      spaceId: $spaceId\n      voteKind: $voteKind\n    ) {\n      voteType\n    }\n  }\n"];
 /**
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
-export function graphql(source: "\n  query EntityVoters($objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId }) {\n      userId\n      voteType\n    }\n  }\n"): (typeof documents)["\n  query EntityVoters($objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId }) {\n      userId\n      voteType\n    }\n  }\n"];
+export function graphql(source: "\n  query EntityResponders($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId, voteKind: $voteKind }) {\n      userId\n      voteType\n    }\n  }\n"): (typeof documents)["\n  query EntityResponders($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {\n    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId, voteKind: $voteKind }) {\n      userId\n      voteType\n    }\n  }\n"];
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n  query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!) {\n    userVotes(filter: $filter, first: $first, offset: $offset, orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]) {\n      userId\n      objectId\n      voteType\n      voteKind\n    }\n  }\n"): (typeof documents)["\n  query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!) {\n    userVotes(filter: $filter, first: $first, offset: $offset, orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]) {\n      userId\n      objectId\n      voteType\n      voteKind\n    }\n  }\n"];
 /**
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
diff --git a/apps/web/core/gql/graphql.ts b/apps/web/core/gql/graphql.ts
index 13ab4b89ed..9b2e835797 100644
--- a/apps/web/core/gql/graphql.ts
+++ b/apps/web/core/gql/graphql.ts
@@ -1,610 +1,127 @@
 /* eslint-disable */
-import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = T | null | undefined;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
-export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+/** Internal type. DO NOT USE DIRECTLY. */
+type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+/** Internal type. DO NOT USE DIRECTLY. */
 export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
-/** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {
-  ID: { input: string; output: string; }
-  String: { input: string; output: string; }
-  Boolean: { input: boolean; output: boolean; }
-  Int: { input: number; output: number; }
-  Float: { input: number; output: number; }
-  /** A floating point number that requires more precision than IEEE 754 binary 64 */
-  BigFloat: { input: any; output: any; }
-  /**
-   * A signed eight-byte integer. The upper big integer values are greater than the
-   * max value for a JavaScript number. Therefore all big integers will be output as
-   * strings and not numbers.
-   */
-  BigInt: { input: any; output: any; }
-  /** Base64-encoded binary data (RFC 4648). */
-  Bytes: { input: any; output: any; }
-  /** A location in a connection that can be used for resuming pagination. */
-  Cursor: { input: any; output: any; }
-  /** Calendar date without time or timezone. Format: "YYYY-MM-DD" (ISO 8601). Unlike the Date scalar, this preserves the original string representation. */
-  DateString: { input: any; output: any; }
-  /** Date and time with optional timezone. Format: ISO 8601 (e.g., "2024-01-15T14:30:00" or "2024-01-15T14:30:00+05:30"). Preserves original timezone offset. */
-  DateTimeString: { input: any; output: any; }
-  /**
-   * A point in time as described by the [ISO
-   * 8601](https://en.wikipedia.org/wiki/ISO_8601) standard. May or may not include a timezone.
-   */
-  Datetime: { input: any; output: any; }
-  /** WGS84 geographic coordinate. Format: "lat,lon" or "lat,lon,alt" where lat is [-90,90], lon is [-180,180], and alt is meters above ellipsoid. */
-  GeoPoint: { input: any; output: any; }
-  /** WGS84 axis-aligned bounding box. Format: "min_lat,min_lon,max_lat,max_lon" (southwest corner, then northeast corner). Coordinates follow same bounds as GeoPoint. */
-  GeoRect: { input: any; output: any; }
-  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
-  JSON: { input: any; output: any; }
-  /** BCP 47 language tag (e.g., "en", "en-US", "zh-Hans-CN"). */
-  LanguageTag: { input: any; output: any; }
-  /** The exact time of day, does not include the date. May or may not have a timezone offset. */
-  Time: { input: any; output: any; }
-  /** Time of day without date. Format: "HH:MM:SS" or "HH:MM:SS.sss" (ISO 8601). May include timezone offset. */
-  TimeString: { input: any; output: any; }
-  /** A universally unique identifier (UUID) as per RFC 4122. Accepts dashed or undashed input; always serializes without dashes. */
-  UUID: { input: any; output: any; }
-};
-
-export type AppWebhook = Node & {
-  __typename?: 'AppWebhook';
-  appName: Scalars['String']['output'];
-  createdAt: Scalars['Datetime']['output'];
-  id: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads and enables pagination through a set of `NotificationDelivery`. */
-  notificationDeliveriesByWebhookId: Array<NotificationDelivery>;
-  /** Reads and enables pagination through a set of `NotificationDelivery`. */
-  notificationDeliveriesByWebhookIdConnection: NotificationDeliveriesConnection;
-  notificationTypes?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
-  secret: Scalars['String']['output'];
-  spaceIds?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;
-  updatedAt: Scalars['Datetime']['output'];
-  url: Scalars['String']['output'];
-};
-
-
-export type AppWebhookNotificationDeliveriesByWebhookIdArgs = {
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-
-export type AppWebhookNotificationDeliveriesByWebhookIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-/**
- * A condition to be used against `AppWebhook` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type AppWebhookCondition = {
-  /** Checks for equality with the object’s `appName` field. */
-  appName?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `notificationTypes` field. */
-  notificationTypes?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Checks for equality with the object’s `secret` field. */
-  secret?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `spaceIds` field. */
-  spaceIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `url` field. */
-  url?: InputMaybe<Scalars['String']['input']>;
-};
-
-/** A filter to be used against `AppWebhook` object types. All fields are combined with a logical ‘and.’ */
-export type AppWebhookFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<AppWebhookFilter>>;
-  /** Filter by the object’s `appName` field. */
-  appName?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<AppWebhookFilter>;
-  /** Filter by the object’s `notificationDeliveriesByWebhookIdConnection` relation. */
-  notificationDeliveriesByWebhookIdConnection?: InputMaybe<AppWebhookToManyNotificationDeliveryFilter>;
-  /** Some related `notificationDeliveriesByWebhookIdConnection` exist. */
-  notificationDeliveriesByWebhookIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Filter by the object’s `notificationTypes` field. */
-  notificationTypes?: InputMaybe<StringListFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<AppWebhookFilter>>;
-  /** Filter by the object’s `secret` field. */
-  secret?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `spaceIds` field. */
-  spaceIds?: InputMaybe<UuidListFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `url` field. */
-  url?: InputMaybe<StringFilter>;
-};
-
-/** A filter to be used against many `NotificationDelivery` object types. All fields are combined with a logical ‘and.’ */
-export type AppWebhookToManyNotificationDeliveryFilter = {
-  /** Every related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<NotificationDeliveryFilter>;
-  /** No related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<NotificationDeliveryFilter>;
-  /** Some related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<NotificationDeliveryFilter>;
-};
-
-/** A connection to a list of `AppWebhook` values. */
-export type AppWebhooksConnection = {
-  __typename?: 'AppWebhooksConnection';
-  /** A list of edges which contains the `AppWebhook` and cursor to aid in pagination. */
-  edges: Array<AppWebhooksEdge>;
-  /** A list of `AppWebhook` objects. */
-  nodes: Array<AppWebhook>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `AppWebhook` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `AppWebhook` edge in the connection. */
-export type AppWebhooksEdge = {
-  __typename?: 'AppWebhooksEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `AppWebhook` at the end of the edge. */
-  node: AppWebhook;
-};
-
-/** Methods to use when ordering `AppWebhook`. */
-export enum AppWebhooksOrderBy {
-  AppNameAsc = 'APP_NAME_ASC',
-  AppNameDesc = 'APP_NAME_DESC',
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  NotificationTypesAsc = 'NOTIFICATION_TYPES_ASC',
-  NotificationTypesDesc = 'NOTIFICATION_TYPES_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SecretAsc = 'SECRET_ASC',
-  SecretDesc = 'SECRET_DESC',
-  SpaceIdsAsc = 'SPACE_IDS_ASC',
-  SpaceIdsDesc = 'SPACE_IDS_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC',
-  UrlAsc = 'URL_ASC',
-  UrlDesc = 'URL_DESC'
-}
-
-export type AtlasCheckpoint = Node & {
-  __typename?: 'AtlasCheckpoint';
-  blockNumber: Scalars['BigInt']['output'];
-  cursor: Scalars['String']['output'];
-  graphStateBlob: Scalars['JSON']['output'];
-  graphStateVersion: Scalars['Int']['output'];
-  indexerId: Scalars['String']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  rootSpaceId: Scalars['String']['output'];
-  runtimeCompatibilityMarker: Scalars['String']['output'];
-  schemaVersion: Scalars['Int']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `AtlasCheckpoint` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type AtlasCheckpointCondition = {
-  /** Checks for equality with the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `cursor` field. */
-  cursor?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `graphStateBlob` field. */
-  graphStateBlob?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `graphStateVersion` field. */
-  graphStateVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `indexerId` field. */
-  indexerId?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `rootSpaceId` field. */
-  rootSpaceId?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `runtimeCompatibilityMarker` field. */
-  runtimeCompatibilityMarker?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `schemaVersion` field. */
-  schemaVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `AtlasCheckpoint` object types. All fields are combined with a logical ‘and.’ */
-export type AtlasCheckpointFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<AtlasCheckpointFilter>>;
-  /** Filter by the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `cursor` field. */
-  cursor?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `graphStateBlob` field. */
-  graphStateBlob?: InputMaybe<JsonFilter>;
-  /** Filter by the object’s `graphStateVersion` field. */
-  graphStateVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `indexerId` field. */
-  indexerId?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<AtlasCheckpointFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<AtlasCheckpointFilter>>;
-  /** Filter by the object’s `rootSpaceId` field. */
-  rootSpaceId?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `runtimeCompatibilityMarker` field. */
-  runtimeCompatibilityMarker?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `schemaVersion` field. */
-  schemaVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `AtlasCheckpoint` values. */
-export type AtlasCheckpointsConnection = {
-  __typename?: 'AtlasCheckpointsConnection';
-  /** A list of edges which contains the `AtlasCheckpoint` and cursor to aid in pagination. */
-  edges: Array<AtlasCheckpointsEdge>;
-  /** A list of `AtlasCheckpoint` objects. */
-  nodes: Array<AtlasCheckpoint>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `AtlasCheckpoint` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `AtlasCheckpoint` edge in the connection. */
-export type AtlasCheckpointsEdge = {
-  __typename?: 'AtlasCheckpointsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `AtlasCheckpoint` at the end of the edge. */
-  node: AtlasCheckpoint;
-};
-
-/** Methods to use when ordering `AtlasCheckpoint`. */
-export enum AtlasCheckpointsOrderBy {
-  BlockNumberAsc = 'BLOCK_NUMBER_ASC',
-  BlockNumberDesc = 'BLOCK_NUMBER_DESC',
-  CursorAsc = 'CURSOR_ASC',
-  CursorDesc = 'CURSOR_DESC',
-  GraphStateBlobAsc = 'GRAPH_STATE_BLOB_ASC',
-  GraphStateBlobDesc = 'GRAPH_STATE_BLOB_DESC',
-  GraphStateVersionAsc = 'GRAPH_STATE_VERSION_ASC',
-  GraphStateVersionDesc = 'GRAPH_STATE_VERSION_DESC',
-  IndexerIdAsc = 'INDEXER_ID_ASC',
-  IndexerIdDesc = 'INDEXER_ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  RootSpaceIdAsc = 'ROOT_SPACE_ID_ASC',
-  RootSpaceIdDesc = 'ROOT_SPACE_ID_DESC',
-  RuntimeCompatibilityMarkerAsc = 'RUNTIME_COMPATIBILITY_MARKER_ASC',
-  RuntimeCompatibilityMarkerDesc = 'RUNTIME_COMPATIBILITY_MARKER_DESC',
-  SchemaVersionAsc = 'SCHEMA_VERSION_ASC',
-  SchemaVersionDesc = 'SCHEMA_VERSION_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
 /** A filter to be used against BigFloat fields. All fields are combined with a logical ‘and.’ */
 export type BigFloatFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['BigFloat']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['BigFloat']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['BigFloat']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['BigFloat']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against BigInt fields. All fields are combined with a logical ‘and.’ */
 export type BigIntFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['BigInt']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['BigInt']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['BigInt']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['BigInt']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against Boolean fields. All fields are combined with a logical ‘and.’ */
 export type BooleanFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
+  distinctFrom?: boolean | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['Boolean']['input']>;
+  greaterThan?: boolean | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
+  greaterThanOrEqualTo?: boolean | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+  in?: Array<boolean> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['Boolean']['input']>;
+  is?: boolean | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['Boolean']['input']>;
+  isNot?: boolean | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['Boolean']['input']>;
+  lessThan?: boolean | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
+  lessThanOrEqualTo?: boolean | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
+  notDistinctFrom?: boolean | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+  notIn?: Array<boolean> | null | undefined;
 };
 
 /** A filter to be used against Datetime fields. All fields are combined with a logical ‘and.’ */
 export type DatetimeFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['Datetime']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['Datetime']['input']>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['Datetime']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['Datetime']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['Datetime']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['Datetime']['input']>>;
-};
-
-export type EditVersion = Node & {
-  __typename?: 'EditVersion';
-  blockNumber: Scalars['BigInt']['output'];
-  createdAt: Scalars['Datetime']['output'];
-  createdById?: Maybe<Scalars['UUID']['output']>;
-  editId: Scalars['UUID']['output'];
-  name?: Maybe<Scalars['String']['output']>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  sequence: Scalars['BigInt']['output'];
-  versionKey: Scalars['BigInt']['output'];
-};
-
-/**
- * A condition to be used against `EditVersion` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type EditVersionCondition = {
-  /** Checks for equality with the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `createdById` field. */
-  createdById?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `editId` field. */
-  editId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `name` field. */
-  name?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `sequence` field. */
-  sequence?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `versionKey` field. */
-  versionKey?: InputMaybe<Scalars['BigInt']['input']>;
-};
-
-/** A filter to be used against `EditVersion` object types. All fields are combined with a logical ‘and.’ */
-export type EditVersionFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<EditVersionFilter>>;
-  /** Filter by the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `createdById` field. */
-  createdById?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `editId` field. */
-  editId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<EditVersionFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<EditVersionFilter>>;
-  /** Filter by the object’s `sequence` field. */
-  sequence?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `versionKey` field. */
-  versionKey?: InputMaybe<BigIntFilter>;
-};
-
-/** A connection to a list of `EditVersion` values. */
-export type EditVersionsConnection = {
-  __typename?: 'EditVersionsConnection';
-  /** A list of edges which contains the `EditVersion` and cursor to aid in pagination. */
-  edges: Array<EditVersionsEdge>;
-  /** A list of `EditVersion` objects. */
-  nodes: Array<EditVersion>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `EditVersion` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `EditVersion` edge in the connection. */
-export type EditVersionsEdge = {
-  __typename?: 'EditVersionsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `EditVersion` at the end of the edge. */
-  node: EditVersion;
-};
-
-/** Methods to use when ordering `EditVersion`. */
-export enum EditVersionsOrderBy {
-  BlockNumberAsc = 'BLOCK_NUMBER_ASC',
-  BlockNumberDesc = 'BLOCK_NUMBER_DESC',
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  CreatedByIdAsc = 'CREATED_BY_ID_ASC',
-  CreatedByIdDesc = 'CREATED_BY_ID_DESC',
-  EditIdAsc = 'EDIT_ID_ASC',
-  EditIdDesc = 'EDIT_ID_DESC',
-  NameAsc = 'NAME_ASC',
-  NameDesc = 'NAME_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SequenceAsc = 'SEQUENCE_ASC',
-  SequenceDesc = 'SEQUENCE_DESC',
-  VersionKeyAsc = 'VERSION_KEY_ASC',
-  VersionKeyDesc = 'VERSION_KEY_DESC'
-}
-
-export type Editor = Node & {
-  __typename?: 'Editor';
-  memberSpaceId: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `Space` that is related to this `Editor`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-};
-
-/** A condition to be used against `Editor` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type EditorCondition = {
-  /** Checks for equality with the object’s `memberSpaceId` field. */
-  memberSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against `Editor` object types. All fields are combined with a logical ‘and.’ */
 export type EditorFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<EditorFilter>>;
+  and?: Array<EditorFilter> | null | undefined;
   /** Filter by the object’s `memberSpaceId` field. */
-  memberSpaceId?: InputMaybe<UuidFilter>;
+  memberSpaceId?: UuidFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<EditorFilter>;
+  not?: EditorFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<EditorFilter>>;
+  or?: Array<EditorFilter> | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-};
-
-/** A connection to a list of `Editor` values. */
-export type EditorsConnection = {
-  __typename?: 'EditorsConnection';
-  /** A list of edges which contains the `Editor` and cursor to aid in pagination. */
-  edges: Array<EditorsEdge>;
-  /** A list of `Editor` objects. */
-  nodes: Array<Editor>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Editor` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `Editor` edge in the connection. */
-export type EditorsEdge = {
-  __typename?: 'EditorsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Editor` at the end of the edge. */
-  node: Editor;
-};
-
-/** Methods to use when ordering `Editor`. */
-export enum EditorsOrderBy {
-  MemberSpaceIdAsc = 'MEMBER_SPACE_ID_ASC',
-  MemberSpaceIdDesc = 'MEMBER_SPACE_ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC'
-}
-
-/** A connection to a list of `Entity` values. */
-export type EntitiesConnection = {
-  __typename?: 'EntitiesConnection';
-  /** A list of edges which contains the `Entity` and cursor to aid in pagination. */
-  edges: Array<EntitiesEdge>;
-  /** A list of `Entity` objects. */
-  nodes: Array<Entity>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Entity` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `Entity` edge in the connection. */
-export type EntitiesEdge = {
-  __typename?: 'EntitiesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Entity` at the end of the edge. */
-  node: Entity;
+  spaceId?: UuidFilter | null | undefined;
 };
 
 /** Methods to use when ordering `Entity`. */
@@ -624,4717 +141,663 @@ export enum EntitiesOrderBy {
   UpdatedAtDesc = 'UPDATED_AT_DESC'
 }
 
-export type Entity = Node & {
-  __typename?: 'Entity';
-  /** Reads and enables pagination through a set of `Relation`. */
-  backlinks: RelationsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  backlinksList: Array<Relation>;
-  createdAt: Scalars['String']['output'];
-  createdAtBlock: Scalars['String']['output'];
-  description?: Maybe<Scalars['String']['output']>;
-  id: Scalars['UUID']['output'];
-  name?: Maybe<Scalars['String']['output']>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads and enables pagination through a set of `Relation`. */
-  relations: RelationsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsList: Array<Relation>;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsWhereEntity: RelationsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsWhereEntityList: Array<Relation>;
-  spaceIds?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;
-  /** Reads and enables pagination through a set of `Space`. */
-  spacesByTopicId: Array<Space>;
-  /** Reads and enables pagination through a set of `Space`. */
-  spacesByTopicIdConnection: SpacesConnection;
-  /** Reads and enables pagination through a set of `Space`. */
-  spacesIn?: Maybe<Array<Space>>;
-  /** Reads and enables pagination through a set of `Space`. */
-  spacesInConnection: SpacesConnection;
-  /** Reads and enables pagination through a set of `SubspaceTopic`. */
-  subspaceTopicsByTopicId: Array<SubspaceTopic>;
-  /** Reads and enables pagination through a set of `SubspaceTopic`. */
-  subspaceTopicsByTopicIdConnection: SubspaceTopicsConnection;
-  systemTypeIds?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;
-  typeIds?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  types?: Maybe<Array<Entity>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  typesConnection: EntitiesConnection;
-  updatedAt: Scalars['String']['output'];
-  updatedAtBlock: Scalars['String']['output'];
-  /** Reads and enables pagination through a set of `Value`. */
-  values: ValuesConnection;
-  /** Reads and enables pagination through a set of `Value`. */
-  valuesList: Array<Value>;
-};
-
-
-export type EntityBacklinksArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntityBacklinksListArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntityRelationsArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntityRelationsListArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntityRelationsWhereEntityArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntityRelationsWhereEntityListArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type EntitySpacesByTopicIdArgs = {
-  condition?: InputMaybe<SpaceCondition>;
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpacesOrderBy>>;
-};
-
-
-export type EntitySpacesByTopicIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceCondition>;
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpacesOrderBy>>;
-};
-
-
-export type EntitySpacesInArgs = {
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-};
-
-
-export type EntitySpacesInConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-};
-
-
-export type EntitySubspaceTopicsByTopicIdArgs = {
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-export type EntitySubspaceTopicsByTopicIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-export type EntityTypesArgs = {
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-};
-
-
-export type EntityTypesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-};
-
-
-export type EntityValuesArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-
-export type EntityValuesListArgs = {
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-/** A condition to be used against `Entity` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type EntityCondition = {
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `updatedAtBlock` field. */
-  updatedAtBlock?: InputMaybe<Scalars['String']['input']>;
-};
-
 /** A filter to be used against `Entity` object types. All fields are combined with a logical ‘and.’ */
 export type EntityFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<EntityFilter>>;
+  and?: Array<EntityFilter> | null | undefined;
   /** Filter by the object’s `backlinks` relation. */
-  backlinks?: InputMaybe<EntityToManyRelationFilter>;
+  backlinks?: EntityToManyRelationFilter | null | undefined;
   /** Some related `backlinks` exist. */
-  backlinksExist?: InputMaybe<Scalars['Boolean']['input']>;
+  backlinksExist?: boolean | null | undefined;
   /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<StringFilter>;
+  createdAt?: StringFilter | null | undefined;
   /** Filter by the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<StringFilter>;
+  createdAtBlock?: StringFilter | null | undefined;
   /** Filter by the object’s `description` field. */
-  description?: InputMaybe<StringFilter>;
+  description?: StringFilter | null | undefined;
   /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
+  id?: UuidFilter | null | undefined;
   /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
+  name?: StringFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<EntityFilter>;
+  not?: EntityFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<EntityFilter>>;
+  or?: Array<EntityFilter> | null | undefined;
   /** Filter by the object’s `relations` relation. */
-  relations?: InputMaybe<EntityToManyRelationFilter>;
+  relations?: EntityToManyRelationFilter | null | undefined;
   /** Filter by the object’s `relationsByTypeIdConnection` relation. */
-  relationsByTypeIdConnection?: InputMaybe<EntityToManyRelationFilter>;
+  relationsByTypeIdConnection?: EntityToManyRelationFilter | null | undefined;
   /** Some related `relationsByTypeIdConnection` exist. */
-  relationsByTypeIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsByTypeIdConnectionExist?: boolean | null | undefined;
   /** Some related `relations` exist. */
-  relationsExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsExist?: boolean | null | undefined;
   /** Filter by the object’s `relationsWhereEntity` relation. */
-  relationsWhereEntity?: InputMaybe<EntityToManyRelationFilter>;
+  relationsWhereEntity?: EntityToManyRelationFilter | null | undefined;
   /** Some related `relationsWhereEntity` exist. */
-  relationsWhereEntityExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsWhereEntityExist?: boolean | null | undefined;
   /** Filter by the object’s `spaceIds` field. */
-  spaceIds?: InputMaybe<UuidListFilter>;
+  spaceIds?: UuidListFilter | null | undefined;
   /** Filter by the object’s `spacesByTopicIdConnection` relation. */
-  spacesByTopicIdConnection?: InputMaybe<EntityToManySpaceFilter>;
+  spacesByTopicIdConnection?: EntityToManySpaceFilter | null | undefined;
   /** Some related `spacesByTopicIdConnection` exist. */
-  spacesByTopicIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  spacesByTopicIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `subspaceTopicsByTopicIdConnection` relation. */
-  subspaceTopicsByTopicIdConnection?: InputMaybe<EntityToManySubspaceTopicFilter>;
+  subspaceTopicsByTopicIdConnection?: EntityToManySubspaceTopicFilter | null | undefined;
   /** Some related `subspaceTopicsByTopicIdConnection` exist. */
-  subspaceTopicsByTopicIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  subspaceTopicsByTopicIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `systemTypeIds` field. */
-  systemTypeIds?: InputMaybe<UuidListFilter>;
+  systemTypeIds?: UuidListFilter | null | undefined;
   /** Filter by the object’s `typeIds` field. */
-  typeIds?: InputMaybe<UuidListFilter>;
+  typeIds?: UuidListFilter | null | undefined;
   /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<StringFilter>;
+  updatedAt?: StringFilter | null | undefined;
   /** Filter by the object’s `updatedAtBlock` field. */
-  updatedAtBlock?: InputMaybe<StringFilter>;
+  updatedAtBlock?: StringFilter | null | undefined;
   /** Filter by the object’s `values` relation. */
-  values?: InputMaybe<EntityToManyValueFilter>;
+  values?: EntityToManyValueFilter | null | undefined;
   /** Filter by the object’s `valuesByPropertyIdConnection` relation. */
-  valuesByPropertyIdConnection?: InputMaybe<EntityToManyValueFilter>;
+  valuesByPropertyIdConnection?: EntityToManyValueFilter | null | undefined;
   /** Some related `valuesByPropertyIdConnection` exist. */
-  valuesByPropertyIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  valuesByPropertyIdConnectionExist?: boolean | null | undefined;
   /** Some related `values` exist. */
-  valuesExist?: InputMaybe<Scalars['Boolean']['input']>;
+  valuesExist?: boolean | null | undefined;
 };
 
 /** A filter to be used against many `Relation` object types. All fields are combined with a logical ‘and.’ */
 export type EntityToManyRelationFilter = {
   /** Every related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<RelationFilter>;
+  every?: RelationFilter | null | undefined;
   /** No related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<RelationFilter>;
+  none?: RelationFilter | null | undefined;
   /** Some related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<RelationFilter>;
+  some?: RelationFilter | null | undefined;
 };
 
 /** A filter to be used against many `Space` object types. All fields are combined with a logical ‘and.’ */
 export type EntityToManySpaceFilter = {
   /** Every related `Space` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<SpaceFilter>;
+  every?: SpaceFilter | null | undefined;
   /** No related `Space` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<SpaceFilter>;
+  none?: SpaceFilter | null | undefined;
   /** Some related `Space` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<SpaceFilter>;
+  some?: SpaceFilter | null | undefined;
 };
 
 /** A filter to be used against many `SubspaceTopic` object types. All fields are combined with a logical ‘and.’ */
 export type EntityToManySubspaceTopicFilter = {
   /** Every related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<SubspaceTopicFilter>;
+  every?: SubspaceTopicFilter | null | undefined;
   /** No related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<SubspaceTopicFilter>;
+  none?: SubspaceTopicFilter | null | undefined;
   /** Some related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<SubspaceTopicFilter>;
+  some?: SubspaceTopicFilter | null | undefined;
 };
 
 /** A filter to be used against many `Value` object types. All fields are combined with a logical ‘and.’ */
 export type EntityToManyValueFilter = {
   /** Every related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ValueFilter>;
+  every?: ValueFilter | null | undefined;
   /** No related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ValueFilter>;
+  none?: ValueFilter | null | undefined;
   /** Some related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ValueFilter>;
+  some?: ValueFilter | null | undefined;
 };
 
 /** A filter to be used against Float fields. All fields are combined with a logical ‘and.’ */
 export type FloatFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['Float']['input']>;
+  distinctFrom?: number | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['Float']['input']>;
+  greaterThan?: number | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Float']['input']>;
+  greaterThanOrEqualTo?: number | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['Float']['input']>>;
+  in?: Array<number> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['Float']['input']>;
+  is?: number | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['Float']['input']>;
+  isNot?: number | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['Float']['input']>;
+  lessThan?: number | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['Float']['input']>;
+  lessThanOrEqualTo?: number | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['Float']['input']>;
+  notDistinctFrom?: number | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['Float']['input']>>;
-};
-
-export type GlobalScore = Node & {
-  __typename?: 'GlobalScore';
-  entityId: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  score: Scalars['BigFloat']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `GlobalScore` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type GlobalScoreCondition = {
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `score` field. */
-  score?: InputMaybe<Scalars['BigFloat']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `GlobalScore` object types. All fields are combined with a logical ‘and.’ */
-export type GlobalScoreFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<GlobalScoreFilter>>;
-  /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<GlobalScoreFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<GlobalScoreFilter>>;
-  /** Filter by the object’s `score` field. */
-  score?: InputMaybe<BigFloatFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `GlobalScore` values. */
-export type GlobalScoresConnection = {
-  __typename?: 'GlobalScoresConnection';
-  /** A list of edges which contains the `GlobalScore` and cursor to aid in pagination. */
-  edges: Array<GlobalScoresEdge>;
-  /** A list of `GlobalScore` objects. */
-  nodes: Array<GlobalScore>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `GlobalScore` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
+  notIn?: Array<number> | null | undefined;
 };
 
-/** A `GlobalScore` edge in the connection. */
-export type GlobalScoresEdge = {
-  __typename?: 'GlobalScoresEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `GlobalScore` at the end of the edge. */
-  node: GlobalScore;
-};
-
-/** Methods to use when ordering `GlobalScore`. */
-export enum GlobalScoresOrderBy {
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ScoreAsc = 'SCORE_ASC',
-  ScoreDesc = 'SCORE_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
 /** A filter to be used against Int fields. All fields are combined with a logical ‘and.’ */
 export type IntFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['Int']['input']>;
+  distinctFrom?: number | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['Int']['input']>;
+  greaterThan?: number | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
+  greaterThanOrEqualTo?: number | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['Int']['input']>>;
+  in?: Array<number> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['Int']['input']>;
+  is?: number | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['Int']['input']>;
+  isNot?: number | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['Int']['input']>;
+  lessThan?: number | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
+  lessThanOrEqualTo?: number | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['Int']['input']>;
+  notDistinctFrom?: number | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['Int']['input']>>;
+  notIn?: Array<number> | null | undefined;
 };
 
 /** A filter to be used against JSON fields. All fields are combined with a logical ‘and.’ */
 export type JsonFilter = {
   /** Contained by the specified JSON. */
-  containedBy?: InputMaybe<Scalars['JSON']['input']>;
+  containedBy?: any;
   /** Contains all of the specified keys. */
-  containsAllKeys?: InputMaybe<Array<Scalars['String']['input']>>;
+  containsAllKeys?: Array<string> | null | undefined;
   /** Contains any of the specified keys. */
-  containsAnyKeys?: InputMaybe<Array<Scalars['String']['input']>>;
+  containsAnyKeys?: Array<string> | null | undefined;
   /** Contains the specified key. */
-  containsKey?: InputMaybe<Scalars['String']['input']>;
+  containsKey?: string | null | undefined;
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['JSON']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['JSON']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Contains the specified JSON. */
-  in?: InputMaybe<Scalars['JSON']['input']>;
+  in?: any;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['JSON']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['JSON']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['JSON']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['JSON']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['JSON']['input']>>;
-};
-
-export type LocalScore = Node & {
-  __typename?: 'LocalScore';
-  entityId: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  score: Scalars['BigFloat']['output'];
-  spaceId: Scalars['UUID']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `LocalScore` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type LocalScoreCondition = {
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `score` field. */
-  score?: InputMaybe<Scalars['BigFloat']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `LocalScore` object types. All fields are combined with a logical ‘and.’ */
-export type LocalScoreFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<LocalScoreFilter>>;
-  /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<LocalScoreFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<LocalScoreFilter>>;
-  /** Filter by the object’s `score` field. */
-  score?: InputMaybe<BigFloatFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `LocalScore` values. */
-export type LocalScoresConnection = {
-  __typename?: 'LocalScoresConnection';
-  /** A list of edges which contains the `LocalScore` and cursor to aid in pagination. */
-  edges: Array<LocalScoresEdge>;
-  /** A list of `LocalScore` objects. */
-  nodes: Array<LocalScore>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `LocalScore` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `LocalScore` edge in the connection. */
-export type LocalScoresEdge = {
-  __typename?: 'LocalScoresEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `LocalScore` at the end of the edge. */
-  node: LocalScore;
-};
-
-/** Methods to use when ordering `LocalScore`. */
-export enum LocalScoresOrderBy {
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ScoreAsc = 'SCORE_ASC',
-  ScoreDesc = 'SCORE_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
-export type Member = Node & {
-  __typename?: 'Member';
-  memberSpaceId: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `Space` that is related to this `Member`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-};
-
-/** A condition to be used against `Member` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type MemberCondition = {
-  /** Checks for equality with the object’s `memberSpaceId` field. */
-  memberSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against `Member` object types. All fields are combined with a logical ‘and.’ */
 export type MemberFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<MemberFilter>>;
+  and?: Array<MemberFilter> | null | undefined;
   /** Filter by the object’s `memberSpaceId` field. */
-  memberSpaceId?: InputMaybe<UuidFilter>;
+  memberSpaceId?: UuidFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<MemberFilter>;
+  not?: MemberFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<MemberFilter>>;
+  or?: Array<MemberFilter> | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-};
-
-/** A connection to a list of `Member` values. */
-export type MembersConnection = {
-  __typename?: 'MembersConnection';
-  /** A list of edges which contains the `Member` and cursor to aid in pagination. */
-  edges: Array<MembersEdge>;
-  /** A list of `Member` objects. */
-  nodes: Array<Member>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Member` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `Member` edge in the connection. */
-export type MembersEdge = {
-  __typename?: 'MembersEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Member` at the end of the edge. */
-  node: Member;
-};
-
-/** Methods to use when ordering `Member`. */
-export enum MembersOrderBy {
-  MemberSpaceIdAsc = 'MEMBER_SPACE_ID_ASC',
-  MemberSpaceIdDesc = 'MEMBER_SPACE_ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC'
-}
-
-export type Meta = Node & {
-  __typename?: 'Meta';
-  blockNumber: Scalars['String']['output'];
-  cursor: Scalars['String']['output'];
-  id: Scalars['String']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-};
-
-/** A condition to be used against `Meta` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type MetaCondition = {
-  /** Checks for equality with the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `cursor` field. */
-  cursor?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['String']['input']>;
+  spaceId?: UuidFilter | null | undefined;
 };
 
-/** A filter to be used against `Meta` object types. All fields are combined with a logical ‘and.’ */
-export type MetaFilter = {
+/** A filter to be used against `ProposalAction` object types. All fields are combined with a logical ‘and.’ */
+export type ProposalActionFilter = {
+  /** Filter by the object’s `actionType` field. */
+  actionType?: ProposalActionTypeFilter | null | undefined;
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<MetaFilter>>;
-  /** Filter by the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `cursor` field. */
-  cursor?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<StringFilter>;
+  and?: Array<ProposalActionFilter> | null | undefined;
+  /** Filter by the object’s `contentUri` field. */
+  contentUri?: StringFilter | null | undefined;
+  /** Filter by the object’s `disableFastPathAccessForNewMembers` field. */
+  disableFastPathAccessForNewMembers?: BooleanFilter | null | undefined;
+  /** Filter by the object’s `duration` field. */
+  duration?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `executionGracePeriod` field. */
+  executionGracePeriod?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `fastThreshold` field. */
+  fastThreshold?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `flatSupportThreshold` field. */
+  flatSupportThreshold?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `index` field. */
+  index?: IntFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<MetaFilter>;
+  not?: ProposalActionFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<MetaFilter>>;
-};
-
-/** A connection to a list of `Meta` values. */
-export type MetasConnection = {
-  __typename?: 'MetasConnection';
-  /** A list of edges which contains the `Meta` and cursor to aid in pagination. */
-  edges: Array<MetasEdge>;
-  /** A list of `Meta` objects. */
-  nodes: Array<Meta>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Meta` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
+  or?: Array<ProposalActionFilter> | null | undefined;
+  /** Filter by the object’s `partialPercentageSupportThreshold` field. */
+  partialPercentageSupportThreshold?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `proposalId` field. */
+  proposalId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `proposalVersion` field. */
+  proposalVersion?: IntFilter | null | undefined;
+  /** Filter by the object’s `proposalVersionByProposalIdAndProposalVersion` relation. */
+  proposalVersionByProposalIdAndProposalVersion?: ProposalVersionFilter | null | undefined;
+  /** Filter by the object’s `quorum` field. */
+  quorum?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `slowThreshold` field. */
+  slowThreshold?: BigIntFilter | null | undefined;
+  /** Filter by the object’s `targetId` field. */
+  targetId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `universalPercentageSupportThreshold` field. */
+  universalPercentageSupportThreshold?: BigIntFilter | null | undefined;
 };
 
-/** A `Meta` edge in the connection. */
-export type MetasEdge = {
-  __typename?: 'MetasEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Meta` at the end of the edge. */
-  node: Meta;
-};
-
-/** Methods to use when ordering `Meta`. */
-export enum MetasOrderBy {
-  BlockNumberAsc = 'BLOCK_NUMBER_ASC',
-  BlockNumberDesc = 'BLOCK_NUMBER_DESC',
-  CursorAsc = 'CURSOR_ASC',
-  CursorDesc = 'CURSOR_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC'
-}
-
-/** An object with a globally unique `ID`. */
-export type Node = {
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-};
-
-/** A connection to a list of `NotificationDelivery` values. */
-export type NotificationDeliveriesConnection = {
-  __typename?: 'NotificationDeliveriesConnection';
-  /** A list of edges which contains the `NotificationDelivery` and cursor to aid in pagination. */
-  edges: Array<NotificationDeliveriesEdge>;
-  /** A list of `NotificationDelivery` objects. */
-  nodes: Array<NotificationDelivery>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `NotificationDelivery` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `NotificationDelivery` edge in the connection. */
-export type NotificationDeliveriesEdge = {
-  __typename?: 'NotificationDeliveriesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `NotificationDelivery` at the end of the edge. */
-  node: NotificationDelivery;
-};
-
-/** Methods to use when ordering `NotificationDelivery`. */
-export enum NotificationDeliveriesOrderBy {
-  AttemptsAsc = 'ATTEMPTS_ASC',
-  AttemptsDesc = 'ATTEMPTS_DESC',
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  DeliveredAtAsc = 'DELIVERED_AT_ASC',
-  DeliveredAtDesc = 'DELIVERED_AT_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  LastErrorAsc = 'LAST_ERROR_ASC',
-  LastErrorDesc = 'LAST_ERROR_DESC',
-  Natural = 'NATURAL',
-  NextRetryAtAsc = 'NEXT_RETRY_AT_ASC',
-  NextRetryAtDesc = 'NEXT_RETRY_AT_DESC',
-  OutboxIdAsc = 'OUTBOX_ID_ASC',
-  OutboxIdDesc = 'OUTBOX_ID_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  StatusAsc = 'STATUS_ASC',
-  StatusDesc = 'STATUS_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC',
-  WebhookIdAsc = 'WEBHOOK_ID_ASC',
-  WebhookIdDesc = 'WEBHOOK_ID_DESC'
-}
-
-export type NotificationDelivery = Node & {
-  __typename?: 'NotificationDelivery';
-  attempts: Scalars['Int']['output'];
-  createdAt: Scalars['Datetime']['output'];
-  deliveredAt?: Maybe<Scalars['Datetime']['output']>;
-  id: Scalars['UUID']['output'];
-  lastError?: Maybe<Scalars['String']['output']>;
-  nextRetryAt: Scalars['Datetime']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `NotificationOutbox` that is related to this `NotificationDelivery`. */
-  outbox?: Maybe<NotificationOutbox>;
-  outboxId: Scalars['UUID']['output'];
-  status: Scalars['String']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-  /** Reads a single `AppWebhook` that is related to this `NotificationDelivery`. */
-  webhook?: Maybe<AppWebhook>;
-  webhookId: Scalars['UUID']['output'];
-};
-
-/**
- * A condition to be used against `NotificationDelivery` object types. All fields
- * are tested for equality and combined with a logical ‘and.’
- */
-export type NotificationDeliveryCondition = {
-  /** Checks for equality with the object’s `attempts` field. */
-  attempts?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `deliveredAt` field. */
-  deliveredAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `lastError` field. */
-  lastError?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `nextRetryAt` field. */
-  nextRetryAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `outboxId` field. */
-  outboxId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `status` field. */
-  status?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `webhookId` field. */
-  webhookId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-/** A filter to be used against `NotificationDelivery` object types. All fields are combined with a logical ‘and.’ */
-export type NotificationDeliveryFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<NotificationDeliveryFilter>>;
-  /** Filter by the object’s `attempts` field. */
-  attempts?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `deliveredAt` field. */
-  deliveredAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `lastError` field. */
-  lastError?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `nextRetryAt` field. */
-  nextRetryAt?: InputMaybe<DatetimeFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<NotificationDeliveryFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<NotificationDeliveryFilter>>;
-  /** Filter by the object’s `outbox` relation. */
-  outbox?: InputMaybe<NotificationOutboxFilter>;
-  /** Filter by the object’s `outboxId` field. */
-  outboxId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `status` field. */
-  status?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `webhook` relation. */
-  webhook?: InputMaybe<AppWebhookFilter>;
-  /** Filter by the object’s `webhookId` field. */
-  webhookId?: InputMaybe<UuidFilter>;
-};
-
-export type NotificationOutbox = Node & {
-  __typename?: 'NotificationOutbox';
-  createdAt: Scalars['Datetime']['output'];
-  eventType: Scalars['String']['output'];
-  id: Scalars['UUID']['output'];
-  idempotencyKey: Scalars['String']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads and enables pagination through a set of `NotificationDelivery`. */
-  notificationDeliveriesByOutboxId: Array<NotificationDelivery>;
-  /** Reads and enables pagination through a set of `NotificationDelivery`. */
-  notificationDeliveriesByOutboxIdConnection: NotificationDeliveriesConnection;
-  payload: Scalars['JSON']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-
-export type NotificationOutboxNotificationDeliveriesByOutboxIdArgs = {
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-
-export type NotificationOutboxNotificationDeliveriesByOutboxIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-/**
- * A condition to be used against `NotificationOutbox` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type NotificationOutboxCondition = {
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `eventType` field. */
-  eventType?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `idempotencyKey` field. */
-  idempotencyKey?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `payload` field. */
-  payload?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `NotificationOutbox` object types. All fields are combined with a logical ‘and.’ */
-export type NotificationOutboxFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<NotificationOutboxFilter>>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `eventType` field. */
-  eventType?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `idempotencyKey` field. */
-  idempotencyKey?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<NotificationOutboxFilter>;
-  /** Filter by the object’s `notificationDeliveriesByOutboxIdConnection` relation. */
-  notificationDeliveriesByOutboxIdConnection?: InputMaybe<NotificationOutboxToManyNotificationDeliveryFilter>;
-  /** Some related `notificationDeliveriesByOutboxIdConnection` exist. */
-  notificationDeliveriesByOutboxIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<NotificationOutboxFilter>>;
-  /** Filter by the object’s `payload` field. */
-  payload?: InputMaybe<JsonFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A filter to be used against many `NotificationDelivery` object types. All fields are combined with a logical ‘and.’ */
-export type NotificationOutboxToManyNotificationDeliveryFilter = {
-  /** Every related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<NotificationDeliveryFilter>;
-  /** No related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<NotificationDeliveryFilter>;
-  /** Some related `NotificationDelivery` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<NotificationDeliveryFilter>;
-};
-
-/** A connection to a list of `NotificationOutbox` values. */
-export type NotificationOutboxesConnection = {
-  __typename?: 'NotificationOutboxesConnection';
-  /** A list of edges which contains the `NotificationOutbox` and cursor to aid in pagination. */
-  edges: Array<NotificationOutboxesEdge>;
-  /** A list of `NotificationOutbox` objects. */
-  nodes: Array<NotificationOutbox>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `NotificationOutbox` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `NotificationOutbox` edge in the connection. */
-export type NotificationOutboxesEdge = {
-  __typename?: 'NotificationOutboxesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `NotificationOutbox` at the end of the edge. */
-  node: NotificationOutbox;
-};
-
-/** Methods to use when ordering `NotificationOutbox`. */
-export enum NotificationOutboxesOrderBy {
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  EventTypeAsc = 'EVENT_TYPE_ASC',
-  EventTypeDesc = 'EVENT_TYPE_DESC',
-  IdempotencyKeyAsc = 'IDEMPOTENCY_KEY_ASC',
-  IdempotencyKeyDesc = 'IDEMPOTENCY_KEY_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  PayloadAsc = 'PAYLOAD_ASC',
-  PayloadDesc = 'PAYLOAD_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
-export type NotificationPollCursor = Node & {
-  __typename?: 'NotificationPollCursor';
-  cursorId: Scalars['BigInt']['output'];
-  cursorUpdatedAt: Scalars['Datetime']['output'];
-  name: Scalars['String']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `NotificationPollCursor` object types. All fields
- * are tested for equality and combined with a logical ‘and.’
- */
-export type NotificationPollCursorCondition = {
-  /** Checks for equality with the object’s `cursorId` field. */
-  cursorId?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `cursorUpdatedAt` field. */
-  cursorUpdatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `name` field. */
-  name?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `NotificationPollCursor` object types. All fields are combined with a logical ‘and.’ */
-export type NotificationPollCursorFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<NotificationPollCursorFilter>>;
-  /** Filter by the object’s `cursorId` field. */
-  cursorId?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `cursorUpdatedAt` field. */
-  cursorUpdatedAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<NotificationPollCursorFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<NotificationPollCursorFilter>>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `NotificationPollCursor` values. */
-export type NotificationPollCursorsConnection = {
-  __typename?: 'NotificationPollCursorsConnection';
-  /** A list of edges which contains the `NotificationPollCursor` and cursor to aid in pagination. */
-  edges: Array<NotificationPollCursorsEdge>;
-  /** A list of `NotificationPollCursor` objects. */
-  nodes: Array<NotificationPollCursor>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `NotificationPollCursor` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `NotificationPollCursor` edge in the connection. */
-export type NotificationPollCursorsEdge = {
-  __typename?: 'NotificationPollCursorsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `NotificationPollCursor` at the end of the edge. */
-  node: NotificationPollCursor;
-};
-
-/** Methods to use when ordering `NotificationPollCursor`. */
-export enum NotificationPollCursorsOrderBy {
-  CursorIdAsc = 'CURSOR_ID_ASC',
-  CursorIdDesc = 'CURSOR_ID_DESC',
-  CursorUpdatedAtAsc = 'CURSOR_UPDATED_AT_ASC',
-  CursorUpdatedAtDesc = 'CURSOR_UPDATED_AT_DESC',
-  NameAsc = 'NAME_ASC',
-  NameDesc = 'NAME_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
-/** Information about pagination in a connection. */
-export type PageInfo = {
-  __typename?: 'PageInfo';
-  /** When paginating forwards, the cursor to continue. */
-  endCursor?: Maybe<Scalars['Cursor']['output']>;
-  /** When paginating forwards, are there more items? */
-  hasNextPage: Scalars['Boolean']['output'];
-  /** When paginating backwards, are there more items? */
-  hasPreviousPage: Scalars['Boolean']['output'];
-  /** When paginating backwards, the cursor to continue. */
-  startCursor?: Maybe<Scalars['Cursor']['output']>;
-};
-
-export type PropertyInfo = {
-  __typename?: 'PropertyInfo';
-  dataTypeId?: Maybe<Scalars['UUID']['output']>;
-  dataTypeName?: Maybe<Scalars['String']['output']>;
-  description?: Maybe<Scalars['String']['output']>;
-  format?: Maybe<Scalars['String']['output']>;
-  id?: Maybe<Scalars['UUID']['output']>;
-  isType?: Maybe<Scalars['Boolean']['output']>;
-  name?: Maybe<Scalars['String']['output']>;
-  renderableTypeId?: Maybe<Scalars['UUID']['output']>;
-  renderableTypeName?: Maybe<Scalars['String']['output']>;
-};
-
-/** A filter to be used against `PropertyInfo` object types. All fields are combined with a logical ‘and.’ */
-export type PropertyInfoFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<PropertyInfoFilter>>;
-  /** Filter by the object’s `dataTypeId` field. */
-  dataTypeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `dataTypeName` field. */
-  dataTypeName?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `description` field. */
-  description?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `format` field. */
-  format?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `isType` field. */
-  isType?: InputMaybe<BooleanFilter>;
-  /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<PropertyInfoFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<PropertyInfoFilter>>;
-  /** Filter by the object’s `renderableTypeId` field. */
-  renderableTypeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `renderableTypeName` field. */
-  renderableTypeName?: InputMaybe<StringFilter>;
-};
-
-/** A connection to a list of `PropertyInfo` values. */
-export type PropertyInfosConnection = {
-  __typename?: 'PropertyInfosConnection';
-  /** A list of edges which contains the `PropertyInfo` and cursor to aid in pagination. */
-  edges: Array<PropertyInfosEdge>;
-  /** A list of `PropertyInfo` objects. */
-  nodes: Array<PropertyInfo>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `PropertyInfo` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `PropertyInfo` edge in the connection. */
-export type PropertyInfosEdge = {
-  __typename?: 'PropertyInfosEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `PropertyInfo` at the end of the edge. */
-  node: PropertyInfo;
-};
-
-export type Proposal = Node & {
-  __typename?: 'Proposal';
-  createdAt: Scalars['String']['output'];
-  createdAtBlock: Scalars['String']['output'];
-  currentVersion: Scalars['Int']['output'];
-  executedAt?: Maybe<Scalars['BigInt']['output']>;
-  id: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `ProposalTallyQueue` that is related to this `Proposal`. */
-  proposalTallyQueue?: Maybe<ProposalTallyQueue>;
-  /**
-   * Reads and enables pagination through a set of `ProposalTallyQueue`.
-   * @deprecated Please use proposalTallyQueue instead
-   */
-  proposalTallyQueuesConnection: ProposalTallyQueuesConnection;
-  /** Reads and enables pagination through a set of `ProposalVersion`. */
-  proposalVersions: Array<ProposalVersion>;
-  /** Reads and enables pagination through a set of `ProposalVersion`. */
-  proposalVersionsConnection: ProposalVersionsConnection;
-  proposedBy: Scalars['UUID']['output'];
-  /** Reads a single `Space` that is related to this `Proposal`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-};
-
-
-export type ProposalProposalTallyQueuesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalTallyQueueCondition>;
-  filter?: InputMaybe<ProposalTallyQueueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalTallyQueuesOrderBy>>;
-};
-
-
-export type ProposalProposalVersionsArgs = {
-  condition?: InputMaybe<ProposalVersionCondition>;
-  filter?: InputMaybe<ProposalVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVersionsOrderBy>>;
-};
-
-
-export type ProposalProposalVersionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalVersionCondition>;
-  filter?: InputMaybe<ProposalVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVersionsOrderBy>>;
-};
-
-export type ProposalAction = Node & {
-  __typename?: 'ProposalAction';
-  actionType: ProposalActionType;
-  contentId?: Maybe<Scalars['String']['output']>;
-  contentUri?: Maybe<Scalars['String']['output']>;
-  disableFastPathAccessForNewMembers?: Maybe<Scalars['Boolean']['output']>;
-  duration?: Maybe<Scalars['BigInt']['output']>;
-  executionGracePeriod?: Maybe<Scalars['BigInt']['output']>;
-  fastThreshold?: Maybe<Scalars['BigInt']['output']>;
-  flatSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-  index: Scalars['Int']['output'];
-  metadata?: Maybe<Scalars['String']['output']>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  partialPercentageSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-  proposalId: Scalars['UUID']['output'];
-  proposalVersion: Scalars['Int']['output'];
-  /** Reads a single `ProposalVersion` that is related to this `ProposalAction`. */
-  proposalVersionByProposalIdAndProposalVersion?: Maybe<ProposalVersion>;
-  quorum?: Maybe<Scalars['BigInt']['output']>;
-  slowThreshold?: Maybe<Scalars['BigInt']['output']>;
-  targetId?: Maybe<Scalars['UUID']['output']>;
-  universalPercentageSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-};
-
-/**
- * A condition to be used against `ProposalAction` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ProposalActionCondition = {
-  /** Checks for equality with the object’s `actionType` field. */
-  actionType?: InputMaybe<ProposalActionType>;
-  /** Checks for equality with the object’s `contentId` field. */
-  contentId?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `contentUri` field. */
-  contentUri?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `disableFastPathAccessForNewMembers` field. */
-  disableFastPathAccessForNewMembers?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for equality with the object’s `duration` field. */
-  duration?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `executionGracePeriod` field. */
-  executionGracePeriod?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `fastThreshold` field. */
-  fastThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `index` field. */
-  index?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `metadata` field. */
-  metadata?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `proposalId` field. */
-  proposalId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `quorum` field. */
-  quorum?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `slowThreshold` field. */
-  slowThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `targetId` field. */
-  targetId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-};
-
-/** A filter to be used against `ProposalAction` object types. All fields are combined with a logical ‘and.’ */
-export type ProposalActionFilter = {
-  /** Filter by the object’s `actionType` field. */
-  actionType?: InputMaybe<ProposalActionTypeFilter>;
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalActionFilter>>;
-  /** Filter by the object’s `contentUri` field. */
-  contentUri?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `disableFastPathAccessForNewMembers` field. */
-  disableFastPathAccessForNewMembers?: InputMaybe<BooleanFilter>;
-  /** Filter by the object’s `duration` field. */
-  duration?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `executionGracePeriod` field. */
-  executionGracePeriod?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `fastThreshold` field. */
-  fastThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `index` field. */
-  index?: InputMaybe<IntFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<ProposalActionFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalActionFilter>>;
-  /** Filter by the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `proposalId` field. */
-  proposalId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `proposalVersionByProposalIdAndProposalVersion` relation. */
-  proposalVersionByProposalIdAndProposalVersion?: InputMaybe<ProposalVersionFilter>;
-  /** Filter by the object’s `quorum` field. */
-  quorum?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `slowThreshold` field. */
-  slowThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `targetId` field. */
-  targetId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
-};
-
-export enum ProposalActionType {
-  AddEditor = 'ADD_EDITOR',
-  AddMember = 'ADD_MEMBER',
-  Flag = 'FLAG',
-  Publish = 'PUBLISH',
-  RemoveEditor = 'REMOVE_EDITOR',
-  RemoveMember = 'REMOVE_MEMBER',
-  SetTopic = 'SET_TOPIC',
-  SubspaceRelated = 'SUBSPACE_RELATED',
-  SubspaceTopicDeclared = 'SUBSPACE_TOPIC_DECLARED',
-  SubspaceTopicRemoved = 'SUBSPACE_TOPIC_REMOVED',
-  SubspaceUnrelated = 'SUBSPACE_UNRELATED',
-  SubspaceUnverified = 'SUBSPACE_UNVERIFIED',
-  SubspaceVerified = 'SUBSPACE_VERIFIED',
-  Unflag = 'UNFLAG',
-  UnflagEditor = 'UNFLAG_EDITOR',
-  Unknown = 'UNKNOWN',
-  UnsetTopic = 'UNSET_TOPIC',
-  UpdateVotingSettings = 'UPDATE_VOTING_SETTINGS'
-}
+export enum ProposalActionType {
+  AddEditor = 'ADD_EDITOR',
+  AddMember = 'ADD_MEMBER',
+  Flag = 'FLAG',
+  Publish = 'PUBLISH',
+  RemoveEditor = 'REMOVE_EDITOR',
+  RemoveMember = 'REMOVE_MEMBER',
+  SetTopic = 'SET_TOPIC',
+  SubspaceRelated = 'SUBSPACE_RELATED',
+  SubspaceTopicDeclared = 'SUBSPACE_TOPIC_DECLARED',
+  SubspaceTopicRemoved = 'SUBSPACE_TOPIC_REMOVED',
+  SubspaceUnrelated = 'SUBSPACE_UNRELATED',
+  SubspaceUnverified = 'SUBSPACE_UNVERIFIED',
+  SubspaceVerified = 'SUBSPACE_VERIFIED',
+  Unflag = 'UNFLAG',
+  UnflagEditor = 'UNFLAG_EDITOR',
+  Unknown = 'UNKNOWN',
+  UnsetTopic = 'UNSET_TOPIC',
+  UpdateVotingSettings = 'UPDATE_VOTING_SETTINGS'
+}
 
 /** A filter to be used against ProposalActionType fields. All fields are combined with a logical ‘and.’ */
 export type ProposalActionTypeFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<ProposalActionType>;
+  distinctFrom?: ProposalActionType | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<ProposalActionType>;
+  greaterThan?: ProposalActionType | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<ProposalActionType>;
+  greaterThanOrEqualTo?: ProposalActionType | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<ProposalActionType>>;
+  in?: Array<ProposalActionType> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<ProposalActionType>;
+  is?: ProposalActionType | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<ProposalActionType>;
+  isNot?: ProposalActionType | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<ProposalActionType>;
+  lessThan?: ProposalActionType | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<ProposalActionType>;
+  lessThanOrEqualTo?: ProposalActionType | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<ProposalActionType>;
+  notDistinctFrom?: ProposalActionType | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<ProposalActionType>>;
-};
-
-/** A connection to a list of `ProposalAction` values. */
-export type ProposalActionsConnection = {
-  __typename?: 'ProposalActionsConnection';
-  /** A list of edges which contains the `ProposalAction` and cursor to aid in pagination. */
-  edges: Array<ProposalActionsEdge>;
-  /** A list of `ProposalAction` objects. */
-  nodes: Array<ProposalAction>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ProposalAction` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ProposalAction` edge in the connection. */
-export type ProposalActionsEdge = {
-  __typename?: 'ProposalActionsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ProposalAction` at the end of the edge. */
-  node: ProposalAction;
-};
-
-/** Methods to use when ordering `ProposalAction`. */
-export enum ProposalActionsOrderBy {
-  ActionTypeAsc = 'ACTION_TYPE_ASC',
-  ActionTypeDesc = 'ACTION_TYPE_DESC',
-  ContentIdAsc = 'CONTENT_ID_ASC',
-  ContentIdDesc = 'CONTENT_ID_DESC',
-  ContentUriAsc = 'CONTENT_URI_ASC',
-  ContentUriDesc = 'CONTENT_URI_DESC',
-  DisableFastPathAccessForNewMembersAsc = 'DISABLE_FAST_PATH_ACCESS_FOR_NEW_MEMBERS_ASC',
-  DisableFastPathAccessForNewMembersDesc = 'DISABLE_FAST_PATH_ACCESS_FOR_NEW_MEMBERS_DESC',
-  DurationAsc = 'DURATION_ASC',
-  DurationDesc = 'DURATION_DESC',
-  ExecutionGracePeriodAsc = 'EXECUTION_GRACE_PERIOD_ASC',
-  ExecutionGracePeriodDesc = 'EXECUTION_GRACE_PERIOD_DESC',
-  FastThresholdAsc = 'FAST_THRESHOLD_ASC',
-  FastThresholdDesc = 'FAST_THRESHOLD_DESC',
-  FlatSupportThresholdAsc = 'FLAT_SUPPORT_THRESHOLD_ASC',
-  FlatSupportThresholdDesc = 'FLAT_SUPPORT_THRESHOLD_DESC',
-  IndexAsc = 'INDEX_ASC',
-  IndexDesc = 'INDEX_DESC',
-  MetadataAsc = 'METADATA_ASC',
-  MetadataDesc = 'METADATA_DESC',
-  Natural = 'NATURAL',
-  PartialPercentageSupportThresholdAsc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  PartialPercentageSupportThresholdDesc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ProposalIdAsc = 'PROPOSAL_ID_ASC',
-  ProposalIdDesc = 'PROPOSAL_ID_DESC',
-  ProposalVersionAsc = 'PROPOSAL_VERSION_ASC',
-  ProposalVersionDesc = 'PROPOSAL_VERSION_DESC',
-  QuorumAsc = 'QUORUM_ASC',
-  QuorumDesc = 'QUORUM_DESC',
-  SlowThresholdAsc = 'SLOW_THRESHOLD_ASC',
-  SlowThresholdDesc = 'SLOW_THRESHOLD_DESC',
-  TargetIdAsc = 'TARGET_ID_ASC',
-  TargetIdDesc = 'TARGET_ID_DESC',
-  UniversalPercentageSupportThresholdAsc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  UniversalPercentageSupportThresholdDesc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC'
-}
-
-/**
- * A condition to be used against `Proposal` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type ProposalCondition = {
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `currentVersion` field. */
-  currentVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `executedAt` field. */
-  executedAt?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `proposedBy` field. */
-  proposedBy?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  notIn?: Array<ProposalActionType> | null | undefined;
 };
 
 /** A filter to be used against `Proposal` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalFilter>>;
+  and?: Array<ProposalFilter> | null | undefined;
   /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<StringFilter>;
+  createdAt?: StringFilter | null | undefined;
   /** Filter by the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<StringFilter>;
+  createdAtBlock?: StringFilter | null | undefined;
   /** Filter by the object’s `currentVersion` field. */
-  currentVersion?: InputMaybe<IntFilter>;
+  currentVersion?: IntFilter | null | undefined;
   /** Filter by the object’s `executedAt` field. */
-  executedAt?: InputMaybe<BigIntFilter>;
+  executedAt?: BigIntFilter | null | undefined;
   /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
+  id?: UuidFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<ProposalFilter>;
+  not?: ProposalFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalFilter>>;
+  or?: Array<ProposalFilter> | null | undefined;
   /** Filter by the object’s `proposalTallyQueue` relation. */
-  proposalTallyQueue?: InputMaybe<ProposalTallyQueueFilter>;
+  proposalTallyQueue?: ProposalTallyQueueFilter | null | undefined;
   /** A related `proposalTallyQueue` exists. */
-  proposalTallyQueueExists?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalTallyQueueExists?: boolean | null | undefined;
   /** Filter by the object’s `proposalVersionsConnection` relation. */
-  proposalVersionsConnection?: InputMaybe<ProposalToManyProposalVersionFilter>;
+  proposalVersionsConnection?: ProposalToManyProposalVersionFilter | null | undefined;
   /** Some related `proposalVersionsConnection` exist. */
-  proposalVersionsConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalVersionsConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `proposedBy` field. */
-  proposedBy?: InputMaybe<UuidFilter>;
+  proposedBy?: UuidFilter | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-};
-
-export type ProposalTallyQueue = Node & {
-  __typename?: 'ProposalTallyQueue';
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `Proposal` that is related to this `ProposalTallyQueue`. */
-  proposal?: Maybe<Proposal>;
-  proposalId: Scalars['UUID']['output'];
-  queuedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `ProposalTallyQueue` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ProposalTallyQueueCondition = {
-  /** Checks for equality with the object’s `proposalId` field. */
-  proposalId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `queuedAt` field. */
-  queuedAt?: InputMaybe<Scalars['Datetime']['input']>;
+  spaceId?: UuidFilter | null | undefined;
 };
 
 /** A filter to be used against `ProposalTallyQueue` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalTallyQueueFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalTallyQueueFilter>>;
+  and?: Array<ProposalTallyQueueFilter> | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<ProposalTallyQueueFilter>;
+  not?: ProposalTallyQueueFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalTallyQueueFilter>>;
+  or?: Array<ProposalTallyQueueFilter> | null | undefined;
   /** Filter by the object’s `proposal` relation. */
-  proposal?: InputMaybe<ProposalFilter>;
+  proposal?: ProposalFilter | null | undefined;
   /** Filter by the object’s `proposalId` field. */
-  proposalId?: InputMaybe<UuidFilter>;
+  proposalId?: UuidFilter | null | undefined;
   /** Filter by the object’s `queuedAt` field. */
-  queuedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `ProposalTallyQueue` values. */
-export type ProposalTallyQueuesConnection = {
-  __typename?: 'ProposalTallyQueuesConnection';
-  /** A list of edges which contains the `ProposalTallyQueue` and cursor to aid in pagination. */
-  edges: Array<ProposalTallyQueuesEdge>;
-  /** A list of `ProposalTallyQueue` objects. */
-  nodes: Array<ProposalTallyQueue>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ProposalTallyQueue` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ProposalTallyQueue` edge in the connection. */
-export type ProposalTallyQueuesEdge = {
-  __typename?: 'ProposalTallyQueuesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ProposalTallyQueue` at the end of the edge. */
-  node: ProposalTallyQueue;
+  queuedAt?: DatetimeFilter | null | undefined;
 };
 
-/** Methods to use when ordering `ProposalTallyQueue`. */
-export enum ProposalTallyQueuesOrderBy {
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ProposalIdAsc = 'PROPOSAL_ID_ASC',
-  ProposalIdDesc = 'PROPOSAL_ID_DESC',
-  QueuedAtAsc = 'QUEUED_AT_ASC',
-  QueuedAtDesc = 'QUEUED_AT_DESC'
-}
-
 /** A filter to be used against many `ProposalVersion` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalToManyProposalVersionFilter = {
   /** Every related `ProposalVersion` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ProposalVersionFilter>;
+  every?: ProposalVersionFilter | null | undefined;
   /** No related `ProposalVersion` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ProposalVersionFilter>;
+  none?: ProposalVersionFilter | null | undefined;
   /** Some related `ProposalVersion` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ProposalVersionFilter>;
-};
-
-export type ProposalVersion = Node & {
-  __typename?: 'ProposalVersion';
-  abstainCount: Scalars['BigInt']['output'];
-  endTime: Scalars['BigInt']['output'];
-  executeBy?: Maybe<Scalars['BigInt']['output']>;
-  flatSupportThreshold: Scalars['BigInt']['output'];
-  name?: Maybe<Scalars['String']['output']>;
-  noCount: Scalars['BigInt']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  partialPercentageSupportThreshold: Scalars['BigInt']['output'];
-  /** Reads a single `Proposal` that is related to this `ProposalVersion`. */
-  proposal?: Maybe<Proposal>;
-  /** Reads and enables pagination through a set of `ProposalAction`. */
-  proposalActionsByProposalIdAndProposalVersion: Array<ProposalAction>;
-  /** Reads and enables pagination through a set of `ProposalAction`. */
-  proposalActionsByProposalIdAndProposalVersionConnection: ProposalActionsConnection;
-  proposalId: Scalars['UUID']['output'];
-  proposalVersion: Scalars['Int']['output'];
-  /** Reads and enables pagination through a set of `ProposalVote`. */
-  proposalVotesByProposalIdAndProposalVersion: Array<ProposalVote>;
-  /** Reads and enables pagination through a set of `ProposalVote`. */
-  proposalVotesByProposalIdAndProposalVersionConnection: ProposalVotesConnection;
-  quorum: Scalars['BigInt']['output'];
-  startTime: Scalars['BigInt']['output'];
-  threshold: Scalars['BigInt']['output'];
-  universalPercentageSupportThreshold: Scalars['BigInt']['output'];
-  versionCreatedAt: Scalars['String']['output'];
-  versionCreatedAtBlock: Scalars['String']['output'];
-  votingMode: VotingMode;
-  yesCount: Scalars['BigInt']['output'];
-};
-
-
-export type ProposalVersionProposalActionsByProposalIdAndProposalVersionArgs = {
-  condition?: InputMaybe<ProposalActionCondition>;
-  filter?: InputMaybe<ProposalActionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalActionsOrderBy>>;
-};
-
-
-export type ProposalVersionProposalActionsByProposalIdAndProposalVersionConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalActionCondition>;
-  filter?: InputMaybe<ProposalActionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalActionsOrderBy>>;
-};
-
-
-export type ProposalVersionProposalVotesByProposalIdAndProposalVersionArgs = {
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-
-export type ProposalVersionProposalVotesByProposalIdAndProposalVersionConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-/**
- * A condition to be used against `ProposalVersion` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ProposalVersionCondition = {
-  /** Checks for equality with the object’s `abstainCount` field. */
-  abstainCount?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `endTime` field. */
-  endTime?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `executeBy` field. */
-  executeBy?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `name` field. */
-  name?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `noCount` field. */
-  noCount?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `proposalId` field. */
-  proposalId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `quorum` field. */
-  quorum?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `startTime` field. */
-  startTime?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `threshold` field. */
-  threshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `versionCreatedAt` field. */
-  versionCreatedAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `versionCreatedAtBlock` field. */
-  versionCreatedAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `votingMode` field. */
-  votingMode?: InputMaybe<VotingMode>;
-  /** Checks for equality with the object’s `yesCount` field. */
-  yesCount?: InputMaybe<Scalars['BigInt']['input']>;
+  some?: ProposalVersionFilter | null | undefined;
 };
 
 /** A filter to be used against `ProposalVersion` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalVersionFilter = {
   /** Filter by the object’s `abstainCount` field. */
-  abstainCount?: InputMaybe<BigIntFilter>;
+  abstainCount?: BigIntFilter | null | undefined;
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalVersionFilter>>;
+  and?: Array<ProposalVersionFilter> | null | undefined;
   /** Filter by the object’s `endTime` field. */
-  endTime?: InputMaybe<BigIntFilter>;
+  endTime?: BigIntFilter | null | undefined;
   /** Filter by the object’s `executeBy` field. */
-  executeBy?: InputMaybe<BigIntFilter>;
+  executeBy?: BigIntFilter | null | undefined;
   /** Filter by the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<BigIntFilter>;
+  flatSupportThreshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
+  name?: StringFilter | null | undefined;
   /** Filter by the object’s `noCount` field. */
-  noCount?: InputMaybe<BigIntFilter>;
+  noCount?: BigIntFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<ProposalVersionFilter>;
+  not?: ProposalVersionFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalVersionFilter>>;
+  or?: Array<ProposalVersionFilter> | null | undefined;
   /** Filter by the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
+  partialPercentageSupportThreshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `proposal` relation. */
-  proposal?: InputMaybe<ProposalFilter>;
+  proposal?: ProposalFilter | null | undefined;
   /** Filter by the object’s `proposalActionsByProposalIdAndProposalVersionConnection` relation. */
-  proposalActionsByProposalIdAndProposalVersionConnection?: InputMaybe<ProposalVersionToManyProposalActionFilter>;
+  proposalActionsByProposalIdAndProposalVersionConnection?: ProposalVersionToManyProposalActionFilter | null | undefined;
   /** Some related `proposalActionsByProposalIdAndProposalVersionConnection` exist. */
-  proposalActionsByProposalIdAndProposalVersionConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalActionsByProposalIdAndProposalVersionConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `proposalId` field. */
-  proposalId?: InputMaybe<UuidFilter>;
+  proposalId?: UuidFilter | null | undefined;
   /** Filter by the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<IntFilter>;
+  proposalVersion?: IntFilter | null | undefined;
   /** Filter by the object’s `proposalVotesByProposalIdAndProposalVersionConnection` relation. */
-  proposalVotesByProposalIdAndProposalVersionConnection?: InputMaybe<ProposalVersionToManyProposalVoteFilter>;
+  proposalVotesByProposalIdAndProposalVersionConnection?: ProposalVersionToManyProposalVoteFilter | null | undefined;
   /** Some related `proposalVotesByProposalIdAndProposalVersionConnection` exist. */
-  proposalVotesByProposalIdAndProposalVersionConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalVotesByProposalIdAndProposalVersionConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `quorum` field. */
-  quorum?: InputMaybe<BigIntFilter>;
+  quorum?: BigIntFilter | null | undefined;
   /** Filter by the object’s `startTime` field. */
-  startTime?: InputMaybe<BigIntFilter>;
+  startTime?: BigIntFilter | null | undefined;
   /** Filter by the object’s `threshold` field. */
-  threshold?: InputMaybe<BigIntFilter>;
+  threshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
+  universalPercentageSupportThreshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `versionCreatedAt` field. */
-  versionCreatedAt?: InputMaybe<StringFilter>;
+  versionCreatedAt?: StringFilter | null | undefined;
   /** Filter by the object’s `versionCreatedAtBlock` field. */
-  versionCreatedAtBlock?: InputMaybe<StringFilter>;
+  versionCreatedAtBlock?: StringFilter | null | undefined;
   /** Filter by the object’s `votingMode` field. */
-  votingMode?: InputMaybe<VotingModeFilter>;
+  votingMode?: VotingModeFilter | null | undefined;
   /** Filter by the object’s `yesCount` field. */
-  yesCount?: InputMaybe<BigIntFilter>;
+  yesCount?: BigIntFilter | null | undefined;
 };
 
 /** A filter to be used against many `ProposalAction` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalVersionToManyProposalActionFilter = {
   /** Every related `ProposalAction` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ProposalActionFilter>;
+  every?: ProposalActionFilter | null | undefined;
   /** No related `ProposalAction` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ProposalActionFilter>;
+  none?: ProposalActionFilter | null | undefined;
   /** Some related `ProposalAction` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ProposalActionFilter>;
+  some?: ProposalActionFilter | null | undefined;
 };
 
 /** A filter to be used against many `ProposalVote` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalVersionToManyProposalVoteFilter = {
   /** Every related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ProposalVoteFilter>;
+  every?: ProposalVoteFilter | null | undefined;
   /** No related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ProposalVoteFilter>;
+  none?: ProposalVoteFilter | null | undefined;
   /** Some related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ProposalVoteFilter>;
-};
-
-/** A connection to a list of `ProposalVersion` values. */
-export type ProposalVersionsConnection = {
-  __typename?: 'ProposalVersionsConnection';
-  /** A list of edges which contains the `ProposalVersion` and cursor to aid in pagination. */
-  edges: Array<ProposalVersionsEdge>;
-  /** A list of `ProposalVersion` objects. */
-  nodes: Array<ProposalVersion>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ProposalVersion` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ProposalVersion` edge in the connection. */
-export type ProposalVersionsEdge = {
-  __typename?: 'ProposalVersionsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ProposalVersion` at the end of the edge. */
-  node: ProposalVersion;
-};
-
-/** Methods to use when ordering `ProposalVersion`. */
-export enum ProposalVersionsOrderBy {
-  AbstainCountAsc = 'ABSTAIN_COUNT_ASC',
-  AbstainCountDesc = 'ABSTAIN_COUNT_DESC',
-  EndTimeAsc = 'END_TIME_ASC',
-  EndTimeDesc = 'END_TIME_DESC',
-  ExecuteByAsc = 'EXECUTE_BY_ASC',
-  ExecuteByDesc = 'EXECUTE_BY_DESC',
-  FlatSupportThresholdAsc = 'FLAT_SUPPORT_THRESHOLD_ASC',
-  FlatSupportThresholdDesc = 'FLAT_SUPPORT_THRESHOLD_DESC',
-  NameAsc = 'NAME_ASC',
-  NameDesc = 'NAME_DESC',
-  Natural = 'NATURAL',
-  NoCountAsc = 'NO_COUNT_ASC',
-  NoCountDesc = 'NO_COUNT_DESC',
-  PartialPercentageSupportThresholdAsc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  PartialPercentageSupportThresholdDesc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ProposalIdAsc = 'PROPOSAL_ID_ASC',
-  ProposalIdDesc = 'PROPOSAL_ID_DESC',
-  ProposalVersionAsc = 'PROPOSAL_VERSION_ASC',
-  ProposalVersionDesc = 'PROPOSAL_VERSION_DESC',
-  QuorumAsc = 'QUORUM_ASC',
-  QuorumDesc = 'QUORUM_DESC',
-  StartTimeAsc = 'START_TIME_ASC',
-  StartTimeDesc = 'START_TIME_DESC',
-  ThresholdAsc = 'THRESHOLD_ASC',
-  ThresholdDesc = 'THRESHOLD_DESC',
-  UniversalPercentageSupportThresholdAsc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  UniversalPercentageSupportThresholdDesc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  VersionCreatedAtAsc = 'VERSION_CREATED_AT_ASC',
-  VersionCreatedAtBlockAsc = 'VERSION_CREATED_AT_BLOCK_ASC',
-  VersionCreatedAtBlockDesc = 'VERSION_CREATED_AT_BLOCK_DESC',
-  VersionCreatedAtDesc = 'VERSION_CREATED_AT_DESC',
-  VotingModeAsc = 'VOTING_MODE_ASC',
-  VotingModeDesc = 'VOTING_MODE_DESC',
-  YesCountAsc = 'YES_COUNT_ASC',
-  YesCountDesc = 'YES_COUNT_DESC'
-}
-
-export type ProposalVote = Node & {
-  __typename?: 'ProposalVote';
-  createdAt: Scalars['String']['output'];
-  createdAtBlock: Scalars['String']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  proposalId: Scalars['UUID']['output'];
-  proposalVersion: Scalars['Int']['output'];
-  /** Reads a single `ProposalVersion` that is related to this `ProposalVote`. */
-  proposalVersionByProposalIdAndProposalVersion?: Maybe<ProposalVersion>;
-  /** Reads a single `Space` that is related to this `ProposalVote`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-  vote: VoteOption;
-  voterId: Scalars['UUID']['output'];
-};
-
-/**
- * A condition to be used against `ProposalVote` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ProposalVoteCondition = {
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `proposalId` field. */
-  proposalId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `vote` field. */
-  vote?: InputMaybe<VoteOption>;
-  /** Checks for equality with the object’s `voterId` field. */
-  voterId?: InputMaybe<Scalars['UUID']['input']>;
+  some?: ProposalVoteFilter | null | undefined;
 };
 
 /** A filter to be used against `ProposalVote` object types. All fields are combined with a logical ‘and.’ */
 export type ProposalVoteFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalVoteFilter>>;
+  and?: Array<ProposalVoteFilter> | null | undefined;
   /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<StringFilter>;
+  createdAt?: StringFilter | null | undefined;
   /** Filter by the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<StringFilter>;
+  createdAtBlock?: StringFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<ProposalVoteFilter>;
+  not?: ProposalVoteFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalVoteFilter>>;
+  or?: Array<ProposalVoteFilter> | null | undefined;
   /** Filter by the object’s `proposalId` field. */
-  proposalId?: InputMaybe<UuidFilter>;
+  proposalId?: UuidFilter | null | undefined;
   /** Filter by the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `proposalVersionByProposalIdAndProposalVersion` relation. */
-  proposalVersionByProposalIdAndProposalVersion?: InputMaybe<ProposalVersionFilter>;
-  /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `vote` field. */
-  vote?: InputMaybe<VoteOptionFilter>;
-  /** Filter by the object’s `voterId` field. */
-  voterId?: InputMaybe<UuidFilter>;
-};
-
-/** A connection to a list of `ProposalVote` values. */
-export type ProposalVotesConnection = {
-  __typename?: 'ProposalVotesConnection';
-  /** A list of edges which contains the `ProposalVote` and cursor to aid in pagination. */
-  edges: Array<ProposalVotesEdge>;
-  /** A list of `ProposalVote` objects. */
-  nodes: Array<ProposalVote>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ProposalVote` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ProposalVote` edge in the connection. */
-export type ProposalVotesEdge = {
-  __typename?: 'ProposalVotesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ProposalVote` at the end of the edge. */
-  node: ProposalVote;
-};
-
-/** Methods to use when ordering `ProposalVote`. */
-export enum ProposalVotesOrderBy {
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtBlockAsc = 'CREATED_AT_BLOCK_ASC',
-  CreatedAtBlockDesc = 'CREATED_AT_BLOCK_DESC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ProposalIdAsc = 'PROPOSAL_ID_ASC',
-  ProposalIdDesc = 'PROPOSAL_ID_DESC',
-  ProposalVersionAsc = 'PROPOSAL_VERSION_ASC',
-  ProposalVersionDesc = 'PROPOSAL_VERSION_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  VoterIdAsc = 'VOTER_ID_ASC',
-  VoterIdDesc = 'VOTER_ID_DESC',
-  VoteAsc = 'VOTE_ASC',
-  VoteDesc = 'VOTE_DESC'
-}
-
-/** A connection to a list of `Proposal` values. */
-export type ProposalsConnection = {
-  __typename?: 'ProposalsConnection';
-  /** A list of edges which contains the `Proposal` and cursor to aid in pagination. */
-  edges: Array<ProposalsEdge>;
-  /** A list of `Proposal` objects. */
-  nodes: Array<Proposal>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Proposal` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-export type ProposalsCurrent = {
-  __typename?: 'ProposalsCurrent';
-  abstainCount?: Maybe<Scalars['BigInt']['output']>;
-  createdAt?: Maybe<Scalars['String']['output']>;
-  createdAtBlock?: Maybe<Scalars['String']['output']>;
-  currentVersion?: Maybe<Scalars['Int']['output']>;
-  endTime?: Maybe<Scalars['BigInt']['output']>;
-  executeBy?: Maybe<Scalars['BigInt']['output']>;
-  executedAt?: Maybe<Scalars['BigInt']['output']>;
-  flatSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-  id?: Maybe<Scalars['UUID']['output']>;
-  name?: Maybe<Scalars['String']['output']>;
-  noCount?: Maybe<Scalars['BigInt']['output']>;
-  partialPercentageSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-  proposalId?: Maybe<Scalars['UUID']['output']>;
-  proposalVersion?: Maybe<Scalars['Int']['output']>;
-  proposedBy?: Maybe<Scalars['UUID']['output']>;
-  quorum?: Maybe<Scalars['BigInt']['output']>;
-  spaceId?: Maybe<Scalars['UUID']['output']>;
-  startTime?: Maybe<Scalars['BigInt']['output']>;
-  threshold?: Maybe<Scalars['BigInt']['output']>;
-  universalPercentageSupportThreshold?: Maybe<Scalars['BigInt']['output']>;
-  versionCreatedAt?: Maybe<Scalars['String']['output']>;
-  versionCreatedAtBlock?: Maybe<Scalars['String']['output']>;
-  votingMode?: Maybe<VotingMode>;
-  yesCount?: Maybe<Scalars['BigInt']['output']>;
-};
-
-/**
- * A condition to be used against `ProposalsCurrent` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ProposalsCurrentCondition = {
-  /** Checks for equality with the object’s `abstainCount` field. */
-  abstainCount?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `currentVersion` field. */
-  currentVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `endTime` field. */
-  endTime?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `executeBy` field. */
-  executeBy?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `executedAt` field. */
-  executedAt?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `name` field. */
-  name?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `noCount` field. */
-  noCount?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `proposalId` field. */
-  proposalId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `proposedBy` field. */
-  proposedBy?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `quorum` field. */
-  quorum?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `startTime` field. */
-  startTime?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `threshold` field. */
-  threshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `versionCreatedAt` field. */
-  versionCreatedAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `versionCreatedAtBlock` field. */
-  versionCreatedAtBlock?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `votingMode` field. */
-  votingMode?: InputMaybe<VotingMode>;
-  /** Checks for equality with the object’s `yesCount` field. */
-  yesCount?: InputMaybe<Scalars['BigInt']['input']>;
-};
-
-/** A filter to be used against `ProposalsCurrent` object types. All fields are combined with a logical ‘and.’ */
-export type ProposalsCurrentFilter = {
-  /** Filter by the object’s `abstainCount` field. */
-  abstainCount?: InputMaybe<BigIntFilter>;
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ProposalsCurrentFilter>>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `createdAtBlock` field. */
-  createdAtBlock?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `currentVersion` field. */
-  currentVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `endTime` field. */
-  endTime?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `executeBy` field. */
-  executeBy?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `executedAt` field. */
-  executedAt?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `name` field. */
-  name?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `noCount` field. */
-  noCount?: InputMaybe<BigIntFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<ProposalsCurrentFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ProposalsCurrentFilter>>;
-  /** Filter by the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `proposalId` field. */
-  proposalId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `proposalVersion` field. */
-  proposalVersion?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `proposedBy` field. */
-  proposedBy?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `quorum` field. */
-  quorum?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `startTime` field. */
-  startTime?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `threshold` field. */
-  threshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `versionCreatedAt` field. */
-  versionCreatedAt?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `versionCreatedAtBlock` field. */
-  versionCreatedAtBlock?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `votingMode` field. */
-  votingMode?: InputMaybe<VotingModeFilter>;
-  /** Filter by the object’s `yesCount` field. */
-  yesCount?: InputMaybe<BigIntFilter>;
-};
-
-/** A connection to a list of `ProposalsCurrent` values. */
-export type ProposalsCurrentsConnection = {
-  __typename?: 'ProposalsCurrentsConnection';
-  /** A list of edges which contains the `ProposalsCurrent` and cursor to aid in pagination. */
-  edges: Array<ProposalsCurrentsEdge>;
-  /** A list of `ProposalsCurrent` objects. */
-  nodes: Array<ProposalsCurrent>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ProposalsCurrent` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ProposalsCurrent` edge in the connection. */
-export type ProposalsCurrentsEdge = {
-  __typename?: 'ProposalsCurrentsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ProposalsCurrent` at the end of the edge. */
-  node: ProposalsCurrent;
-};
-
-/** Methods to use when ordering `ProposalsCurrent`. */
-export enum ProposalsCurrentsOrderBy {
-  AbstainCountAsc = 'ABSTAIN_COUNT_ASC',
-  AbstainCountDesc = 'ABSTAIN_COUNT_DESC',
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtBlockAsc = 'CREATED_AT_BLOCK_ASC',
-  CreatedAtBlockDesc = 'CREATED_AT_BLOCK_DESC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  CurrentVersionAsc = 'CURRENT_VERSION_ASC',
-  CurrentVersionDesc = 'CURRENT_VERSION_DESC',
-  EndTimeAsc = 'END_TIME_ASC',
-  EndTimeDesc = 'END_TIME_DESC',
-  ExecutedAtAsc = 'EXECUTED_AT_ASC',
-  ExecutedAtDesc = 'EXECUTED_AT_DESC',
-  ExecuteByAsc = 'EXECUTE_BY_ASC',
-  ExecuteByDesc = 'EXECUTE_BY_DESC',
-  FlatSupportThresholdAsc = 'FLAT_SUPPORT_THRESHOLD_ASC',
-  FlatSupportThresholdDesc = 'FLAT_SUPPORT_THRESHOLD_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  NameAsc = 'NAME_ASC',
-  NameDesc = 'NAME_DESC',
-  Natural = 'NATURAL',
-  NoCountAsc = 'NO_COUNT_ASC',
-  NoCountDesc = 'NO_COUNT_DESC',
-  PartialPercentageSupportThresholdAsc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  PartialPercentageSupportThresholdDesc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  ProposalIdAsc = 'PROPOSAL_ID_ASC',
-  ProposalIdDesc = 'PROPOSAL_ID_DESC',
-  ProposalVersionAsc = 'PROPOSAL_VERSION_ASC',
-  ProposalVersionDesc = 'PROPOSAL_VERSION_DESC',
-  ProposedByAsc = 'PROPOSED_BY_ASC',
-  ProposedByDesc = 'PROPOSED_BY_DESC',
-  QuorumAsc = 'QUORUM_ASC',
-  QuorumDesc = 'QUORUM_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  StartTimeAsc = 'START_TIME_ASC',
-  StartTimeDesc = 'START_TIME_DESC',
-  ThresholdAsc = 'THRESHOLD_ASC',
-  ThresholdDesc = 'THRESHOLD_DESC',
-  UniversalPercentageSupportThresholdAsc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  UniversalPercentageSupportThresholdDesc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  VersionCreatedAtAsc = 'VERSION_CREATED_AT_ASC',
-  VersionCreatedAtBlockAsc = 'VERSION_CREATED_AT_BLOCK_ASC',
-  VersionCreatedAtBlockDesc = 'VERSION_CREATED_AT_BLOCK_DESC',
-  VersionCreatedAtDesc = 'VERSION_CREATED_AT_DESC',
-  VotingModeAsc = 'VOTING_MODE_ASC',
-  VotingModeDesc = 'VOTING_MODE_DESC',
-  YesCountAsc = 'YES_COUNT_ASC',
-  YesCountDesc = 'YES_COUNT_DESC'
-}
-
-/** A `Proposal` edge in the connection. */
-export type ProposalsEdge = {
-  __typename?: 'ProposalsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Proposal` at the end of the edge. */
-  node: Proposal;
-};
-
-/** Methods to use when ordering `Proposal`. */
-export enum ProposalsOrderBy {
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtBlockAsc = 'CREATED_AT_BLOCK_ASC',
-  CreatedAtBlockDesc = 'CREATED_AT_BLOCK_DESC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  CurrentVersionAsc = 'CURRENT_VERSION_ASC',
-  CurrentVersionDesc = 'CURRENT_VERSION_DESC',
-  ExecutedAtAsc = 'EXECUTED_AT_ASC',
-  ExecutedAtDesc = 'EXECUTED_AT_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ProposedByAsc = 'PROPOSED_BY_ASC',
-  ProposedByDesc = 'PROPOSED_BY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC'
-}
-
-/** The root query type which gives access points into the data universe. */
-export type Query = Node & {
-  __typename?: 'Query';
-  appWebhook?: Maybe<AppWebhook>;
-  appWebhookByAppName?: Maybe<AppWebhook>;
-  /** Reads a single `AppWebhook` using its globally unique `ID`. */
-  appWebhookByNodeId?: Maybe<AppWebhook>;
-  /** Reads a set of `AppWebhook`. */
-  appWebhooks?: Maybe<Array<AppWebhook>>;
-  /** Reads and enables pagination through a set of `AppWebhook`. */
-  appWebhooksConnection?: Maybe<AppWebhooksConnection>;
-  atlasCheckpoint?: Maybe<AtlasCheckpoint>;
-  /** Reads a single `AtlasCheckpoint` using its globally unique `ID`. */
-  atlasCheckpointByNodeId?: Maybe<AtlasCheckpoint>;
-  /** Reads a set of `AtlasCheckpoint`. */
-  atlasCheckpoints?: Maybe<Array<AtlasCheckpoint>>;
-  /** Reads and enables pagination through a set of `AtlasCheckpoint`. */
-  atlasCheckpointsConnection?: Maybe<AtlasCheckpointsConnection>;
-  buildPropertyInfo?: Maybe<PropertyInfo>;
-  editVersion?: Maybe<EditVersion>;
-  editVersionByBlockNumberAndSequence?: Maybe<EditVersion>;
-  /** Reads a single `EditVersion` using its globally unique `ID`. */
-  editVersionByNodeId?: Maybe<EditVersion>;
-  /** Reads a set of `EditVersion`. */
-  editVersions?: Maybe<Array<EditVersion>>;
-  /** Reads and enables pagination through a set of `EditVersion`. */
-  editVersionsConnection?: Maybe<EditVersionsConnection>;
-  editor?: Maybe<Editor>;
-  /** Reads a single `Editor` using its globally unique `ID`. */
-  editorByNodeId?: Maybe<Editor>;
-  /** Reads a set of `Editor`. */
-  editors?: Maybe<Array<Editor>>;
-  /** Reads and enables pagination through a set of `Editor`. */
-  editorsConnection?: Maybe<EditorsConnection>;
-  /** Reads a set of `Entity`. */
-  entities?: Maybe<Array<Entity>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  entitiesConnection?: Maybe<EntitiesConnection>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  entitiesOrderedByProperty?: Maybe<Array<Entity>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  entitiesOrderedByPropertyConnection?: Maybe<EntitiesConnection>;
-  entity?: Maybe<Entity>;
-  /** Reads a single `Entity` using its globally unique `ID`. */
-  entityByNodeId?: Maybe<Entity>;
-  globalScore?: Maybe<GlobalScore>;
-  /** Reads a single `GlobalScore` using its globally unique `ID`. */
-  globalScoreByNodeId?: Maybe<GlobalScore>;
-  /** Reads a set of `GlobalScore`. */
-  globalScores?: Maybe<Array<GlobalScore>>;
-  /** Reads and enables pagination through a set of `GlobalScore`. */
-  globalScoresConnection?: Maybe<GlobalScoresConnection>;
-  localScore?: Maybe<LocalScore>;
-  /** Reads a single `LocalScore` using its globally unique `ID`. */
-  localScoreByNodeId?: Maybe<LocalScore>;
-  /** Reads a set of `LocalScore`. */
-  localScores?: Maybe<Array<LocalScore>>;
-  /** Reads and enables pagination through a set of `LocalScore`. */
-  localScoresConnection?: Maybe<LocalScoresConnection>;
-  member?: Maybe<Member>;
-  /** Reads a single `Member` using its globally unique `ID`. */
-  memberByNodeId?: Maybe<Member>;
-  /** Reads a set of `Member`. */
-  members?: Maybe<Array<Member>>;
-  /** Reads and enables pagination through a set of `Member`. */
-  membersConnection?: Maybe<MembersConnection>;
-  meta?: Maybe<Meta>;
-  /** Reads a single `Meta` using its globally unique `ID`. */
-  metaByNodeId?: Maybe<Meta>;
-  /** Reads a set of `Meta`. */
-  metas?: Maybe<Array<Meta>>;
-  /** Reads and enables pagination through a set of `Meta`. */
-  metasConnection?: Maybe<MetasConnection>;
-  /** Fetches an object given its globally unique `ID`. */
-  node?: Maybe<Node>;
-  /** The root query type must be a `Node` to work well with Relay 1 mutations. This just resolves to `query`. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a set of `NotificationDelivery`. */
-  notificationDeliveries?: Maybe<Array<NotificationDelivery>>;
-  /** Reads and enables pagination through a set of `NotificationDelivery`. */
-  notificationDeliveriesConnection?: Maybe<NotificationDeliveriesConnection>;
-  notificationDelivery?: Maybe<NotificationDelivery>;
-  /** Reads a single `NotificationDelivery` using its globally unique `ID`. */
-  notificationDeliveryByNodeId?: Maybe<NotificationDelivery>;
-  notificationDeliveryByOutboxIdAndWebhookId?: Maybe<NotificationDelivery>;
-  notificationOutbox?: Maybe<NotificationOutbox>;
-  notificationOutboxByIdempotencyKey?: Maybe<NotificationOutbox>;
-  /** Reads a single `NotificationOutbox` using its globally unique `ID`. */
-  notificationOutboxByNodeId?: Maybe<NotificationOutbox>;
-  /** Reads a set of `NotificationOutbox`. */
-  notificationOutboxes?: Maybe<Array<NotificationOutbox>>;
-  /** Reads and enables pagination through a set of `NotificationOutbox`. */
-  notificationOutboxesConnection?: Maybe<NotificationOutboxesConnection>;
-  notificationPollCursor?: Maybe<NotificationPollCursor>;
-  /** Reads a single `NotificationPollCursor` using its globally unique `ID`. */
-  notificationPollCursorByNodeId?: Maybe<NotificationPollCursor>;
-  /** Reads a set of `NotificationPollCursor`. */
-  notificationPollCursors?: Maybe<Array<NotificationPollCursor>>;
-  /** Reads and enables pagination through a set of `NotificationPollCursor`. */
-  notificationPollCursorsConnection?: Maybe<NotificationPollCursorsConnection>;
-  /** Reads and enables pagination through a set of `PropertyInfo`. */
-  properties?: Maybe<Array<PropertyInfo>>;
-  /** Reads and enables pagination through a set of `PropertyInfo`. */
-  propertiesConnection?: Maybe<PropertyInfosConnection>;
-  property?: Maybe<PropertyInfo>;
-  proposal?: Maybe<Proposal>;
-  proposalAction?: Maybe<ProposalAction>;
-  /** Reads a single `ProposalAction` using its globally unique `ID`. */
-  proposalActionByNodeId?: Maybe<ProposalAction>;
-  /** Reads a set of `ProposalAction`. */
-  proposalActions?: Maybe<Array<ProposalAction>>;
-  /** Reads and enables pagination through a set of `ProposalAction`. */
-  proposalActionsConnection?: Maybe<ProposalActionsConnection>;
-  /** Reads a single `Proposal` using its globally unique `ID`. */
-  proposalByNodeId?: Maybe<Proposal>;
-  proposalTallyQueue?: Maybe<ProposalTallyQueue>;
-  /** Reads a single `ProposalTallyQueue` using its globally unique `ID`. */
-  proposalTallyQueueByNodeId?: Maybe<ProposalTallyQueue>;
-  /** Reads a set of `ProposalTallyQueue`. */
-  proposalTallyQueues?: Maybe<Array<ProposalTallyQueue>>;
-  /** Reads and enables pagination through a set of `ProposalTallyQueue`. */
-  proposalTallyQueuesConnection?: Maybe<ProposalTallyQueuesConnection>;
-  proposalVersion?: Maybe<ProposalVersion>;
-  /** Reads a single `ProposalVersion` using its globally unique `ID`. */
-  proposalVersionByNodeId?: Maybe<ProposalVersion>;
-  proposalVersionByProposalIdAndVersionCreatedAtBlock?: Maybe<ProposalVersion>;
-  /** Reads a set of `ProposalVersion`. */
-  proposalVersions?: Maybe<Array<ProposalVersion>>;
-  /** Reads and enables pagination through a set of `ProposalVersion`. */
-  proposalVersionsConnection?: Maybe<ProposalVersionsConnection>;
-  proposalVote?: Maybe<ProposalVote>;
-  /** Reads a single `ProposalVote` using its globally unique `ID`. */
-  proposalVoteByNodeId?: Maybe<ProposalVote>;
-  /** Reads a set of `ProposalVote`. */
-  proposalVotes?: Maybe<Array<ProposalVote>>;
-  /** Reads and enables pagination through a set of `ProposalVote`. */
-  proposalVotesConnection?: Maybe<ProposalVotesConnection>;
-  /** Reads a set of `Proposal`. */
-  proposals?: Maybe<Array<Proposal>>;
-  /** Reads and enables pagination through a set of `Proposal`. */
-  proposalsConnection?: Maybe<ProposalsConnection>;
-  /** Reads a set of `ProposalsCurrent`. */
-  proposalsCurrents?: Maybe<Array<ProposalsCurrent>>;
-  /** Reads and enables pagination through a set of `ProposalsCurrent`. */
-  proposalsCurrentsConnection?: Maybe<ProposalsCurrentsConnection>;
-  /**
-   * Exposes the root query type nested one level down. This is helpful for Relay 1
-   * which can only query top level fields if they are in a particular form.
-   */
-  query: Query;
-  relation?: Maybe<Relation>;
-  /** Reads a single `Relation` using its globally unique `ID`. */
-  relationByNodeId?: Maybe<Relation>;
-  relationVersion?: Maybe<RelationVersion>;
-  /** Reads a single `RelationVersion` using its globally unique `ID`. */
-  relationVersionByNodeId?: Maybe<RelationVersion>;
-  /** Reads a set of `RelationVersion`. */
-  relationVersions?: Maybe<Array<RelationVersion>>;
-  /** Reads and enables pagination through a set of `RelationVersion`. */
-  relationVersionsConnection?: Maybe<RelationVersionsConnection>;
-  /** Reads a set of `Relation`. */
-  relations?: Maybe<Array<Relation>>;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsConnection?: Maybe<RelationsConnection>;
-  scoringTopologyDistance?: Maybe<ScoringTopologyDistance>;
-  /** Reads a single `ScoringTopologyDistance` using its globally unique `ID`. */
-  scoringTopologyDistanceByNodeId?: Maybe<ScoringTopologyDistance>;
-  /** Reads a set of `ScoringTopologyDistance`. */
-  scoringTopologyDistances?: Maybe<Array<ScoringTopologyDistance>>;
-  /** Reads and enables pagination through a set of `ScoringTopologyDistance`. */
-  scoringTopologyDistancesConnection?: Maybe<ScoringTopologyDistancesConnection>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  search?: Maybe<Array<Entity>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  searchConnection?: Maybe<EntitiesConnection>;
-  space?: Maybe<Space>;
-  /** Reads a single `Space` using its globally unique `ID`. */
-  spaceByNodeId?: Maybe<Space>;
-  /** Reads a set of `SpaceEditorCount`. */
-  spaceEditorCounts?: Maybe<Array<SpaceEditorCount>>;
-  /** Reads and enables pagination through a set of `SpaceEditorCount`. */
-  spaceEditorCountsConnection?: Maybe<SpaceEditorCountsConnection>;
-  spaceScore?: Maybe<SpaceScore>;
-  /** Reads a single `SpaceScore` using its globally unique `ID`. */
-  spaceScoreByNodeId?: Maybe<SpaceScore>;
-  /** Reads a set of `SpaceScore`. */
-  spaceScores?: Maybe<Array<SpaceScore>>;
-  /** Reads and enables pagination through a set of `SpaceScore`. */
-  spaceScoresConnection?: Maybe<SpaceScoresConnection>;
-  spaceVotingSetting?: Maybe<SpaceVotingSetting>;
-  /** Reads a single `SpaceVotingSetting` using its globally unique `ID`. */
-  spaceVotingSettingByNodeId?: Maybe<SpaceVotingSetting>;
-  /** Reads a set of `SpaceVotingSetting`. */
-  spaceVotingSettings?: Maybe<Array<SpaceVotingSetting>>;
-  /** Reads and enables pagination through a set of `SpaceVotingSetting`. */
-  spaceVotingSettingsConnection?: Maybe<SpaceVotingSettingsConnection>;
-  /** Reads a set of `Space`. */
-  spaces?: Maybe<Array<Space>>;
-  /** Reads and enables pagination through a set of `Space`. */
-  spacesConnection?: Maybe<SpacesConnection>;
-  subspace?: Maybe<Subspace>;
-  /** Reads a single `Subspace` using its globally unique `ID`. */
-  subspaceByNodeId?: Maybe<Subspace>;
-  subspaceTopic?: Maybe<SubspaceTopic>;
-  /** Reads a single `SubspaceTopic` using its globally unique `ID`. */
-  subspaceTopicByNodeId?: Maybe<SubspaceTopic>;
-  /** Reads a set of `SubspaceTopic`. */
-  subspaceTopics?: Maybe<Array<SubspaceTopic>>;
-  /** Reads and enables pagination through a set of `SubspaceTopic`. */
-  subspaceTopicsConnection?: Maybe<SubspaceTopicsConnection>;
-  /** Reads a set of `Subspace`. */
-  subspaces?: Maybe<Array<Subspace>>;
-  /** Reads and enables pagination through a set of `Subspace`. */
-  subspacesConnection?: Maybe<SubspacesConnection>;
-  type?: Maybe<Entity>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  typesList?: Maybe<Array<Entity>>;
-  /** Reads and enables pagination through a set of `Entity`. */
-  typesListConnection?: Maybe<EntitiesConnection>;
-  userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId?: Maybe<UserVote>;
-  /** Reads a set of `UserVote`. */
-  userVotes?: Maybe<Array<UserVote>>;
-  /** Reads and enables pagination through a set of `UserVote`. */
-  userVotesConnection?: Maybe<UserVotesConnection>;
-  value?: Maybe<Value>;
-  /** Reads a single `Value` using its globally unique `ID`. */
-  valueByNodeId?: Maybe<Value>;
-  valueVersion?: Maybe<ValueVersion>;
-  /** Reads a single `ValueVersion` using its globally unique `ID`. */
-  valueVersionByNodeId?: Maybe<ValueVersion>;
-  /** Reads a set of `ValueVersion`. */
-  valueVersions?: Maybe<Array<ValueVersion>>;
-  /** Reads and enables pagination through a set of `ValueVersion`. */
-  valueVersionsConnection?: Maybe<ValueVersionsConnection>;
-  /** Reads a set of `Value`. */
-  values?: Maybe<Array<Value>>;
-  /** Reads and enables pagination through a set of `Value`. */
-  valuesConnection?: Maybe<ValuesConnection>;
-  vote?: Maybe<Vote>;
-  /** Reads a single `Vote` using its globally unique `ID`. */
-  voteByNodeId?: Maybe<Vote>;
-  /** Reads a set of `Vote`. */
-  votes?: Maybe<Array<Vote>>;
-  /** Reads and enables pagination through a set of `Vote`. */
-  votesConnection?: Maybe<VotesConnection>;
-  votesCount?: Maybe<VotesCount>;
-  /** Reads a single `VotesCount` using its globally unique `ID`. */
-  votesCountByNodeId?: Maybe<VotesCount>;
-  votesCountByObjectIdAndObjectTypeAndSpaceId?: Maybe<VotesCount>;
-  /** Reads a set of `VotesCount`. */
-  votesCounts?: Maybe<Array<VotesCount>>;
-  /** Reads and enables pagination through a set of `VotesCount`. */
-  votesCountsConnection?: Maybe<VotesCountsConnection>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAppWebhookArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAppWebhookByAppNameArgs = {
-  appName: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAppWebhookByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAppWebhooksArgs = {
-  condition?: InputMaybe<AppWebhookCondition>;
-  filter?: InputMaybe<AppWebhookFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<AppWebhooksOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAppWebhooksConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<AppWebhookCondition>;
-  filter?: InputMaybe<AppWebhookFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<AppWebhooksOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAtlasCheckpointArgs = {
-  indexerId: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAtlasCheckpointByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAtlasCheckpointsArgs = {
-  condition?: InputMaybe<AtlasCheckpointCondition>;
-  filter?: InputMaybe<AtlasCheckpointFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<AtlasCheckpointsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryAtlasCheckpointsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<AtlasCheckpointCondition>;
-  filter?: InputMaybe<AtlasCheckpointFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<AtlasCheckpointsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryBuildPropertyInfoArgs = {
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditVersionArgs = {
-  editId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditVersionByBlockNumberAndSequenceArgs = {
-  blockNumber: Scalars['BigInt']['input'];
-  sequence: Scalars['BigInt']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditVersionByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditVersionsArgs = {
-  condition?: InputMaybe<EditVersionCondition>;
-  filter?: InputMaybe<EditVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditVersionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<EditVersionCondition>;
-  filter?: InputMaybe<EditVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditorArgs = {
-  memberSpaceId: Scalars['UUID']['input'];
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditorByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditorsArgs = {
-  condition?: InputMaybe<EditorCondition>;
-  filter?: InputMaybe<EditorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditorsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEditorsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<EditorCondition>;
-  filter?: InputMaybe<EditorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditorsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntitiesArgs = {
-  condition?: InputMaybe<EntityCondition>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EntitiesOrderBy>>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  spaceIds?: InputMaybe<UuidFilter>;
-  systemTypeId?: InputMaybe<Scalars['UUID']['input']>;
-  systemTypeIds?: InputMaybe<UuidFilter>;
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  typeIds?: InputMaybe<UuidFilter>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntitiesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<EntityCondition>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EntitiesOrderBy>>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  spaceIds?: InputMaybe<UuidFilter>;
-  systemTypeId?: InputMaybe<Scalars['UUID']['input']>;
-  systemTypeIds?: InputMaybe<UuidFilter>;
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  typeIds?: InputMaybe<UuidFilter>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntitiesOrderedByPropertyArgs = {
-  dataType?: InputMaybe<Scalars['String']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  propertyId?: InputMaybe<Scalars['UUID']['input']>;
-  sortDirection?: InputMaybe<SortOrder>;
-  spaceIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-  typeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntitiesOrderedByPropertyConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  dataType?: InputMaybe<Scalars['String']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  includeWithoutValue?: InputMaybe<Scalars['Boolean']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  propertyId?: InputMaybe<Scalars['UUID']['input']>;
-  sortDirection?: InputMaybe<SortOrder>;
-  spaceIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-  typeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntityArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryEntityByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryGlobalScoreArgs = {
-  entityId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryGlobalScoreByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryGlobalScoresArgs = {
-  condition?: InputMaybe<GlobalScoreCondition>;
-  filter?: InputMaybe<GlobalScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<GlobalScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryGlobalScoresConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<GlobalScoreCondition>;
-  filter?: InputMaybe<GlobalScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<GlobalScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryLocalScoreArgs = {
-  entityId: Scalars['UUID']['input'];
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryLocalScoreByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryLocalScoresArgs = {
-  condition?: InputMaybe<LocalScoreCondition>;
-  filter?: InputMaybe<LocalScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<LocalScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryLocalScoresConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<LocalScoreCondition>;
-  filter?: InputMaybe<LocalScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<LocalScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMemberArgs = {
-  memberSpaceId: Scalars['UUID']['input'];
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMemberByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMembersArgs = {
-  condition?: InputMaybe<MemberCondition>;
-  filter?: InputMaybe<MemberFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MembersOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMembersConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<MemberCondition>;
-  filter?: InputMaybe<MemberFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MembersOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMetaArgs = {
-  id: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMetaByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMetasArgs = {
-  condition?: InputMaybe<MetaCondition>;
-  filter?: InputMaybe<MetaFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MetasOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryMetasConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<MetaCondition>;
-  filter?: InputMaybe<MetaFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MetasOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNodeArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationDeliveriesArgs = {
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationDeliveriesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<NotificationDeliveryCondition>;
-  filter?: InputMaybe<NotificationDeliveryFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationDeliveriesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationDeliveryArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationDeliveryByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationDeliveryByOutboxIdAndWebhookIdArgs = {
-  outboxId: Scalars['UUID']['input'];
-  webhookId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationOutboxArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationOutboxByIdempotencyKeyArgs = {
-  idempotencyKey: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationOutboxByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationOutboxesArgs = {
-  condition?: InputMaybe<NotificationOutboxCondition>;
-  filter?: InputMaybe<NotificationOutboxFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationOutboxesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationOutboxesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<NotificationOutboxCondition>;
-  filter?: InputMaybe<NotificationOutboxFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationOutboxesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationPollCursorArgs = {
-  name: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationPollCursorByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationPollCursorsArgs = {
-  condition?: InputMaybe<NotificationPollCursorCondition>;
-  filter?: InputMaybe<NotificationPollCursorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationPollCursorsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryNotificationPollCursorsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<NotificationPollCursorCondition>;
-  filter?: InputMaybe<NotificationPollCursorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<NotificationPollCursorsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryPropertiesArgs = {
-  filter?: InputMaybe<PropertyInfoFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryPropertiesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  filter?: InputMaybe<PropertyInfoFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryPropertyArgs = {
-  id?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalActionArgs = {
-  index: Scalars['Int']['input'];
-  proposalId: Scalars['UUID']['input'];
-  proposalVersion: Scalars['Int']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalActionByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalActionsArgs = {
-  condition?: InputMaybe<ProposalActionCondition>;
-  filter?: InputMaybe<ProposalActionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalActionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalActionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalActionCondition>;
-  filter?: InputMaybe<ProposalActionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalActionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalTallyQueueArgs = {
-  proposalId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalTallyQueueByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalTallyQueuesArgs = {
-  condition?: InputMaybe<ProposalTallyQueueCondition>;
-  filter?: InputMaybe<ProposalTallyQueueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalTallyQueuesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalTallyQueuesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalTallyQueueCondition>;
-  filter?: InputMaybe<ProposalTallyQueueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalTallyQueuesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVersionArgs = {
-  proposalId: Scalars['UUID']['input'];
-  proposalVersion: Scalars['Int']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVersionByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVersionByProposalIdAndVersionCreatedAtBlockArgs = {
-  proposalId: Scalars['UUID']['input'];
-  versionCreatedAtBlock: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVersionsArgs = {
-  condition?: InputMaybe<ProposalVersionCondition>;
-  filter?: InputMaybe<ProposalVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVersionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalVersionCondition>;
-  filter?: InputMaybe<ProposalVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVoteArgs = {
-  proposalId: Scalars['UUID']['input'];
-  proposalVersion: Scalars['Int']['input'];
-  voterId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVoteByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVotesArgs = {
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalVotesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalsArgs = {
-  condition?: InputMaybe<ProposalCondition>;
-  filter?: InputMaybe<ProposalFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalCondition>;
-  filter?: InputMaybe<ProposalFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalsCurrentsArgs = {
-  condition?: InputMaybe<ProposalsCurrentCondition>;
-  filter?: InputMaybe<ProposalsCurrentFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsCurrentsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryProposalsCurrentsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalsCurrentCondition>;
-  filter?: InputMaybe<ProposalsCurrentFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsCurrentsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationVersionArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationVersionByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationVersionsArgs = {
-  condition?: InputMaybe<RelationVersionCondition>;
-  filter?: InputMaybe<RelationVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationVersionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationVersionCondition>;
-  filter?: InputMaybe<RelationVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationsArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryRelationsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryScoringTopologyDistanceArgs = {
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryScoringTopologyDistanceByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryScoringTopologyDistancesArgs = {
-  condition?: InputMaybe<ScoringTopologyDistanceCondition>;
-  filter?: InputMaybe<ScoringTopologyDistanceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ScoringTopologyDistancesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryScoringTopologyDistancesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ScoringTopologyDistanceCondition>;
-  filter?: InputMaybe<ScoringTopologyDistanceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ScoringTopologyDistancesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySearchArgs = {
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  query?: InputMaybe<Scalars['String']['input']>;
-  similarityThreshold?: InputMaybe<Scalars['Float']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySearchConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  query?: InputMaybe<Scalars['String']['input']>;
-  similarityThreshold?: InputMaybe<Scalars['Float']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceEditorCountsArgs = {
-  condition?: InputMaybe<SpaceEditorCountCondition>;
-  filter?: InputMaybe<SpaceEditorCountFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceEditorCountsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceEditorCountsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceEditorCountCondition>;
-  filter?: InputMaybe<SpaceEditorCountFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceEditorCountsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceScoreArgs = {
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceScoreByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceScoresArgs = {
-  condition?: InputMaybe<SpaceScoreCondition>;
-  filter?: InputMaybe<SpaceScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceScoresConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceScoreCondition>;
-  filter?: InputMaybe<SpaceScoreFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceScoresOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceVotingSettingArgs = {
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceVotingSettingByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceVotingSettingsArgs = {
-  condition?: InputMaybe<SpaceVotingSettingCondition>;
-  filter?: InputMaybe<SpaceVotingSettingFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceVotingSettingsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpaceVotingSettingsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceVotingSettingCondition>;
-  filter?: InputMaybe<SpaceVotingSettingFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceVotingSettingsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpacesArgs = {
-  condition?: InputMaybe<SpaceCondition>;
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpacesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySpacesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceCondition>;
-  filter?: InputMaybe<SpaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpacesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceArgs = {
-  childSpaceId: Scalars['UUID']['input'];
-  parentSpaceId: Scalars['UUID']['input'];
-  type: SubspaceType;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceTopicArgs = {
-  spaceId: Scalars['UUID']['input'];
-  topicId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceTopicByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceTopicsArgs = {
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspaceTopicsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspacesArgs = {
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QuerySubspacesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryTypeArgs = {
-  id?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryTypesListArgs = {
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryTypesListConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryUserVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdArgs = {
-  objectId: Scalars['UUID']['input'];
-  objectType: Scalars['Int']['input'];
-  spaceId: Scalars['UUID']['input'];
-  userId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryUserVotesArgs = {
-  condition?: InputMaybe<UserVoteCondition>;
-  filter?: InputMaybe<UserVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<UserVotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryUserVotesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<UserVoteCondition>;
-  filter?: InputMaybe<UserVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<UserVotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueArgs = {
-  id: Scalars['String']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueVersionArgs = {
-  id: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueVersionByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueVersionsArgs = {
-  condition?: InputMaybe<ValueVersionCondition>;
-  filter?: InputMaybe<ValueVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValueVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValueVersionsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ValueVersionCondition>;
-  filter?: InputMaybe<ValueVersionFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValueVersionsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValuesArgs = {
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryValuesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVoteArgs = {
-  id: Scalars['Int']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVoteByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesArgs = {
-  condition?: InputMaybe<VoteCondition>;
-  filter?: InputMaybe<VoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<VotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<VoteCondition>;
-  filter?: InputMaybe<VoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<VotesOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesCountArgs = {
-  id: Scalars['Int']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesCountByNodeIdArgs = {
-  nodeId: Scalars['ID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesCountByObjectIdAndObjectTypeAndSpaceIdArgs = {
-  objectId: Scalars['UUID']['input'];
-  objectType: Scalars['Int']['input'];
-  spaceId: Scalars['UUID']['input'];
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesCountsArgs = {
-  condition?: InputMaybe<VotesCountCondition>;
-  filter?: InputMaybe<VotesCountFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<VotesCountsOrderBy>>;
-};
-
-
-/** The root query type which gives access points into the data universe. */
-export type QueryVotesCountsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<VotesCountCondition>;
-  filter?: InputMaybe<VotesCountFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<VotesCountsOrderBy>>;
-};
-
-export type Relation = Node & {
-  __typename?: 'Relation';
-  /** Reads a single `Entity` that is related to this `Relation`. */
-  entity?: Maybe<Entity>;
-  entityId: Scalars['UUID']['output'];
-  /** Reads a single `Entity` that is related to this `Relation`. */
-  fromEntity?: Maybe<Entity>;
-  fromEntityId: Scalars['UUID']['output'];
-  /** Reads a single `Space` that is related to this `Relation`. */
-  fromSpace?: Maybe<Space>;
-  fromSpaceId?: Maybe<Scalars['UUID']['output']>;
-  fromVersionId?: Maybe<Scalars['UUID']['output']>;
-  id: Scalars['UUID']['output'];
-  isSystem: Scalars['Boolean']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  position?: Maybe<Scalars['String']['output']>;
-  /** Reads a single `Space` that is related to this `Relation`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-  /** Reads a single `Entity` that is related to this `Relation`. */
-  toEntity?: Maybe<Entity>;
-  toEntityId: Scalars['UUID']['output'];
-  /** Reads a single `Space` that is related to this `Relation`. */
-  toSpace?: Maybe<Space>;
-  toSpaceId?: Maybe<Scalars['UUID']['output']>;
-  toVersionId?: Maybe<Scalars['UUID']['output']>;
-  type?: Maybe<PropertyInfo>;
-  /** Reads a single `Entity` that is related to this `Relation`. */
-  typeEntity?: Maybe<Entity>;
-  typeId: Scalars['UUID']['output'];
-  verified?: Maybe<Scalars['Boolean']['output']>;
-};
-
-/**
- * A condition to be used against `Relation` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type RelationCondition = {
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `fromEntityId` field. */
-  fromEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `fromSpaceId` field. */
-  fromSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `fromVersionId` field. */
-  fromVersionId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `isSystem` field. */
-  isSystem?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for equality with the object’s `position` field. */
-  position?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `toEntityId` field. */
-  toEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `toSpaceId` field. */
-  toSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `toVersionId` field. */
-  toVersionId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `typeId` field. */
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `verified` field. */
-  verified?: InputMaybe<Scalars['Boolean']['input']>;
-};
-
-/** A filter to be used against `Relation` object types. All fields are combined with a logical ‘and.’ */
-export type RelationFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<RelationFilter>>;
-  /** Filter by the object’s `entity` relation. */
-  entity?: InputMaybe<EntityFilter>;
-  /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `fromEntity` relation. */
-  fromEntity?: InputMaybe<EntityFilter>;
-  /** Filter by the object’s `fromEntityId` field. */
-  fromEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `fromSpace` relation. */
-  fromSpace?: InputMaybe<SpaceFilter>;
-  /** A related `fromSpace` exists. */
-  fromSpaceExists?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Filter by the object’s `fromSpaceId` field. */
-  fromSpaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `fromVersionId` field. */
-  fromVersionId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `isSystem` field. */
-  isSystem?: InputMaybe<BooleanFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<RelationFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<RelationFilter>>;
-  /** Filter by the object’s `position` field. */
-  position?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `toEntity` relation. */
-  toEntity?: InputMaybe<EntityFilter>;
-  /** Filter by the object’s `toEntityId` field. */
-  toEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `toSpace` relation. */
-  toSpace?: InputMaybe<SpaceFilter>;
-  /** A related `toSpace` exists. */
-  toSpaceExists?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Filter by the object’s `toSpaceId` field. */
-  toSpaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `toVersionId` field. */
-  toVersionId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `typeEntity` relation. */
-  typeEntity?: InputMaybe<EntityFilter>;
-  /** Filter by the object’s `typeId` field. */
-  typeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `verified` field. */
-  verified?: InputMaybe<BooleanFilter>;
-};
-
-export type RelationVersion = Node & {
-  __typename?: 'RelationVersion';
-  contextEdgeTypeId?: Maybe<Scalars['UUID']['output']>;
-  contextLastToEntityId?: Maybe<Scalars['UUID']['output']>;
-  contextRootId?: Maybe<Scalars['UUID']['output']>;
-  entityId: Scalars['UUID']['output'];
-  fromEntityId: Scalars['UUID']['output'];
-  fromSpaceId?: Maybe<Scalars['UUID']['output']>;
-  id: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  position?: Maybe<Scalars['String']['output']>;
-  relationId: Scalars['UUID']['output'];
-  spaceId: Scalars['UUID']['output'];
-  toEntityId: Scalars['UUID']['output'];
-  toSpaceId?: Maybe<Scalars['UUID']['output']>;
-  typeId: Scalars['UUID']['output'];
-  validFromKey: Scalars['BigInt']['output'];
-  validToKey?: Maybe<Scalars['BigInt']['output']>;
-  verified?: Maybe<Scalars['Boolean']['output']>;
-};
-
-/**
- * A condition to be used against `RelationVersion` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type RelationVersionCondition = {
-  /** Checks for equality with the object’s `contextEdgeTypeId` field. */
-  contextEdgeTypeId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `contextLastToEntityId` field. */
-  contextLastToEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `contextRootId` field. */
-  contextRootId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `fromEntityId` field. */
-  fromEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `fromSpaceId` field. */
-  fromSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `position` field. */
-  position?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `relationId` field. */
-  relationId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `toEntityId` field. */
-  toEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `toSpaceId` field. */
-  toSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `typeId` field. */
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `validFromKey` field. */
-  validFromKey?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `validToKey` field. */
-  validToKey?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `verified` field. */
-  verified?: InputMaybe<Scalars['Boolean']['input']>;
-};
-
-/** A filter to be used against `RelationVersion` object types. All fields are combined with a logical ‘and.’ */
-export type RelationVersionFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<RelationVersionFilter>>;
-  /** Filter by the object’s `contextEdgeTypeId` field. */
-  contextEdgeTypeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `contextLastToEntityId` field. */
-  contextLastToEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `contextRootId` field. */
-  contextRootId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `fromEntityId` field. */
-  fromEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `fromSpaceId` field. */
-  fromSpaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<RelationVersionFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<RelationVersionFilter>>;
-  /** Filter by the object’s `position` field. */
-  position?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `relationId` field. */
-  relationId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `toEntityId` field. */
-  toEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `toSpaceId` field. */
-  toSpaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `typeId` field. */
-  typeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `validFromKey` field. */
-  validFromKey?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `validToKey` field. */
-  validToKey?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `verified` field. */
-  verified?: InputMaybe<BooleanFilter>;
-};
-
-/** A connection to a list of `RelationVersion` values. */
-export type RelationVersionsConnection = {
-  __typename?: 'RelationVersionsConnection';
-  /** A list of edges which contains the `RelationVersion` and cursor to aid in pagination. */
-  edges: Array<RelationVersionsEdge>;
-  /** A list of `RelationVersion` objects. */
-  nodes: Array<RelationVersion>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `RelationVersion` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `RelationVersion` edge in the connection. */
-export type RelationVersionsEdge = {
-  __typename?: 'RelationVersionsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `RelationVersion` at the end of the edge. */
-  node: RelationVersion;
-};
-
-/** Methods to use when ordering `RelationVersion`. */
-export enum RelationVersionsOrderBy {
-  ContextEdgeTypeIdAsc = 'CONTEXT_EDGE_TYPE_ID_ASC',
-  ContextEdgeTypeIdDesc = 'CONTEXT_EDGE_TYPE_ID_DESC',
-  ContextLastToEntityIdAsc = 'CONTEXT_LAST_TO_ENTITY_ID_ASC',
-  ContextLastToEntityIdDesc = 'CONTEXT_LAST_TO_ENTITY_ID_DESC',
-  ContextRootIdAsc = 'CONTEXT_ROOT_ID_ASC',
-  ContextRootIdDesc = 'CONTEXT_ROOT_ID_DESC',
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  FromEntityIdAsc = 'FROM_ENTITY_ID_ASC',
-  FromEntityIdDesc = 'FROM_ENTITY_ID_DESC',
-  FromSpaceIdAsc = 'FROM_SPACE_ID_ASC',
-  FromSpaceIdDesc = 'FROM_SPACE_ID_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  PositionAsc = 'POSITION_ASC',
-  PositionDesc = 'POSITION_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  RelationIdAsc = 'RELATION_ID_ASC',
-  RelationIdDesc = 'RELATION_ID_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  ToEntityIdAsc = 'TO_ENTITY_ID_ASC',
-  ToEntityIdDesc = 'TO_ENTITY_ID_DESC',
-  ToSpaceIdAsc = 'TO_SPACE_ID_ASC',
-  ToSpaceIdDesc = 'TO_SPACE_ID_DESC',
-  TypeIdAsc = 'TYPE_ID_ASC',
-  TypeIdDesc = 'TYPE_ID_DESC',
-  ValidFromKeyAsc = 'VALID_FROM_KEY_ASC',
-  ValidFromKeyDesc = 'VALID_FROM_KEY_DESC',
-  ValidToKeyAsc = 'VALID_TO_KEY_ASC',
-  ValidToKeyDesc = 'VALID_TO_KEY_DESC',
-  VerifiedAsc = 'VERIFIED_ASC',
-  VerifiedDesc = 'VERIFIED_DESC'
-}
-
-/** A connection to a list of `Relation` values. */
-export type RelationsConnection = {
-  __typename?: 'RelationsConnection';
-  /** A list of edges which contains the `Relation` and cursor to aid in pagination. */
-  edges: Array<RelationsEdge>;
-  /** A list of `Relation` objects. */
-  nodes: Array<Relation>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Relation` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `Relation` edge in the connection. */
-export type RelationsEdge = {
-  __typename?: 'RelationsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Relation` at the end of the edge. */
-  node: Relation;
-};
-
-/** Methods to use when ordering `Relation`. */
-export enum RelationsOrderBy {
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  FromEntityIdAsc = 'FROM_ENTITY_ID_ASC',
-  FromEntityIdDesc = 'FROM_ENTITY_ID_DESC',
-  FromSpaceIdAsc = 'FROM_SPACE_ID_ASC',
-  FromSpaceIdDesc = 'FROM_SPACE_ID_DESC',
-  FromVersionIdAsc = 'FROM_VERSION_ID_ASC',
-  FromVersionIdDesc = 'FROM_VERSION_ID_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  IsSystemAsc = 'IS_SYSTEM_ASC',
-  IsSystemDesc = 'IS_SYSTEM_DESC',
-  Natural = 'NATURAL',
-  PositionAsc = 'POSITION_ASC',
-  PositionDesc = 'POSITION_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  ToEntityIdAsc = 'TO_ENTITY_ID_ASC',
-  ToEntityIdDesc = 'TO_ENTITY_ID_DESC',
-  ToSpaceIdAsc = 'TO_SPACE_ID_ASC',
-  ToSpaceIdDesc = 'TO_SPACE_ID_DESC',
-  ToVersionIdAsc = 'TO_VERSION_ID_ASC',
-  ToVersionIdDesc = 'TO_VERSION_ID_DESC',
-  TypeIdAsc = 'TYPE_ID_ASC',
-  TypeIdDesc = 'TYPE_ID_DESC',
-  VerifiedAsc = 'VERIFIED_ASC',
-  VerifiedDesc = 'VERIFIED_DESC'
-}
-
-export type ScoringTopologyDistance = Node & {
-  __typename?: 'ScoringTopologyDistance';
-  distance: Scalars['Int']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  spaceId: Scalars['UUID']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `ScoringTopologyDistance` object types. All
- * fields are tested for equality and combined with a logical ‘and.’
- */
-export type ScoringTopologyDistanceCondition = {
-  /** Checks for equality with the object’s `distance` field. */
-  distance?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `ScoringTopologyDistance` object types. All fields are combined with a logical ‘and.’ */
-export type ScoringTopologyDistanceFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ScoringTopologyDistanceFilter>>;
-  /** Filter by the object’s `distance` field. */
-  distance?: InputMaybe<IntFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<ScoringTopologyDistanceFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ScoringTopologyDistanceFilter>>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `ScoringTopologyDistance` values. */
-export type ScoringTopologyDistancesConnection = {
-  __typename?: 'ScoringTopologyDistancesConnection';
-  /** A list of edges which contains the `ScoringTopologyDistance` and cursor to aid in pagination. */
-  edges: Array<ScoringTopologyDistancesEdge>;
-  /** A list of `ScoringTopologyDistance` objects. */
-  nodes: Array<ScoringTopologyDistance>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ScoringTopologyDistance` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ScoringTopologyDistance` edge in the connection. */
-export type ScoringTopologyDistancesEdge = {
-  __typename?: 'ScoringTopologyDistancesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ScoringTopologyDistance` at the end of the edge. */
-  node: ScoringTopologyDistance;
-};
-
-/** Methods to use when ordering `ScoringTopologyDistance`. */
-export enum ScoringTopologyDistancesOrderBy {
-  DistanceAsc = 'DISTANCE_ASC',
-  DistanceDesc = 'DISTANCE_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
-export enum SortOrder {
-  Asc = 'ASC',
-  Desc = 'DESC'
-}
-
-export type Space = Node & {
-  __typename?: 'Space';
-  address: Scalars['String']['output'];
-  /** Reads and enables pagination through a set of `Editor`. */
-  editors: EditorsConnection;
-  /** Reads and enables pagination through a set of `Editor`. */
-  editorsList: Array<Editor>;
-  id: Scalars['UUID']['output'];
-  /** Reads and enables pagination through a set of `Member`. */
-  members: MembersConnection;
-  /** Reads and enables pagination through a set of `Member`. */
-  membersList: Array<Member>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  page?: Maybe<Entity>;
-  /** Reads and enables pagination through a set of `ProposalVote`. */
-  proposalVotes: Array<ProposalVote>;
-  /** Reads and enables pagination through a set of `ProposalVote`. */
-  proposalVotesConnection: ProposalVotesConnection;
-  /** Reads and enables pagination through a set of `Proposal`. */
-  proposals: Array<Proposal>;
-  /** Reads and enables pagination through a set of `Proposal`. */
-  proposalsConnection: ProposalsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relations: Array<Relation>;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsByFromSpaceId: Array<Relation>;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsByFromSpaceIdConnection: RelationsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsByToSpaceId: Array<Relation>;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsByToSpaceIdConnection: RelationsConnection;
-  /** Reads and enables pagination through a set of `Relation`. */
-  relationsConnection: RelationsConnection;
-  /** Reads a single `SpaceVotingSetting` that is related to this `Space`. */
-  spaceVotingSetting?: Maybe<SpaceVotingSetting>;
-  /**
-   * Reads and enables pagination through a set of `SpaceVotingSetting`.
-   * @deprecated Please use spaceVotingSetting instead
-   */
-  spaceVotingSettingsConnection: SpaceVotingSettingsConnection;
-  /** Reads and enables pagination through a set of `SubspaceTopic`. */
-  subspaceTopics: Array<SubspaceTopic>;
-  /** Reads and enables pagination through a set of `SubspaceTopic`. */
-  subspaceTopicsConnection: SubspaceTopicsConnection;
-  /** Reads and enables pagination through a set of `Subspace`. */
-  subspacesByChildSpaceId: Array<Subspace>;
-  /** Reads and enables pagination through a set of `Subspace`. */
-  subspacesByChildSpaceIdConnection: SubspacesConnection;
-  /** Reads and enables pagination through a set of `Subspace`. */
-  subspacesByParentSpaceId: Array<Subspace>;
-  /** Reads and enables pagination through a set of `Subspace`. */
-  subspacesByParentSpaceIdConnection: SubspacesConnection;
-  /** Reads a single `Entity` that is related to this `Space`. */
-  topic?: Maybe<Entity>;
-  topicId?: Maybe<Scalars['UUID']['output']>;
-  type: SpaceTypes;
-  /** Reads and enables pagination through a set of `Value`. */
-  values: Array<Value>;
-  /** Reads and enables pagination through a set of `Value`. */
-  valuesConnection: ValuesConnection;
-};
-
-
-export type SpaceEditorsArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<EditorCondition>;
-  filter?: InputMaybe<EditorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditorsOrderBy>>;
-};
-
-
-export type SpaceEditorsListArgs = {
-  condition?: InputMaybe<EditorCondition>;
-  filter?: InputMaybe<EditorFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<EditorsOrderBy>>;
-};
-
-
-export type SpaceMembersArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<MemberCondition>;
-  filter?: InputMaybe<MemberFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MembersOrderBy>>;
-};
-
-
-export type SpaceMembersListArgs = {
-  condition?: InputMaybe<MemberCondition>;
-  filter?: InputMaybe<MemberFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<MembersOrderBy>>;
-};
-
-
-export type SpaceProposalVotesArgs = {
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-
-export type SpaceProposalVotesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalVoteCondition>;
-  filter?: InputMaybe<ProposalVoteFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalVotesOrderBy>>;
-};
-
-
-export type SpaceProposalsArgs = {
-  condition?: InputMaybe<ProposalCondition>;
-  filter?: InputMaybe<ProposalFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsOrderBy>>;
-};
-
-
-export type SpaceProposalsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ProposalCondition>;
-  filter?: InputMaybe<ProposalFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ProposalsOrderBy>>;
-};
-
-
-export type SpaceRelationsArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceRelationsByFromSpaceIdArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceRelationsByFromSpaceIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceRelationsByToSpaceIdArgs = {
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceRelationsByToSpaceIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceRelationsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<RelationCondition>;
-  filter?: InputMaybe<RelationFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<RelationsOrderBy>>;
-};
-
-
-export type SpaceSpaceVotingSettingsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SpaceVotingSettingCondition>;
-  filter?: InputMaybe<SpaceVotingSettingFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SpaceVotingSettingsOrderBy>>;
-};
-
-
-export type SpaceSubspaceTopicsArgs = {
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-export type SpaceSubspaceTopicsConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceTopicCondition>;
-  filter?: InputMaybe<SubspaceTopicFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspaceTopicsOrderBy>>;
-};
-
-
-export type SpaceSubspacesByChildSpaceIdArgs = {
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-export type SpaceSubspacesByChildSpaceIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-export type SpaceSubspacesByParentSpaceIdArgs = {
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-export type SpaceSubspacesByParentSpaceIdConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<SubspaceCondition>;
-  filter?: InputMaybe<SubspaceFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<SubspacesOrderBy>>;
-};
-
-
-export type SpaceValuesArgs = {
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-
-export type SpaceValuesConnectionArgs = {
-  after?: InputMaybe<Scalars['Cursor']['input']>;
-  before?: InputMaybe<Scalars['Cursor']['input']>;
-  condition?: InputMaybe<ValueCondition>;
-  filter?: InputMaybe<ValueFilter>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  last?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  orderBy?: InputMaybe<Array<ValuesOrderBy>>;
-};
-
-/** A condition to be used against `Space` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type SpaceCondition = {
-  /** Checks for equality with the object’s `address` field. */
-  address?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `topicId` field. */
-  topicId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `type` field. */
-  type?: InputMaybe<SpaceTypes>;
-};
-
-export type SpaceEditorCount = {
-  __typename?: 'SpaceEditorCount';
-  spaceId?: Maybe<Scalars['UUID']['output']>;
-  totalEditors?: Maybe<Scalars['BigInt']['output']>;
-};
-
-/**
- * A condition to be used against `SpaceEditorCount` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type SpaceEditorCountCondition = {
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `totalEditors` field. */
-  totalEditors?: InputMaybe<Scalars['BigInt']['input']>;
+  proposalVersion?: IntFilter | null | undefined;
+  /** Filter by the object’s `proposalVersionByProposalIdAndProposalVersion` relation. */
+  proposalVersionByProposalIdAndProposalVersion?: ProposalVersionFilter | null | undefined;
+  /** Filter by the object’s `space` relation. */
+  space?: SpaceFilter | null | undefined;
+  /** Filter by the object’s `spaceId` field. */
+  spaceId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `vote` field. */
+  vote?: VoteOptionFilter | null | undefined;
+  /** Filter by the object’s `voterId` field. */
+  voterId?: UuidFilter | null | undefined;
 };
 
-/** A filter to be used against `SpaceEditorCount` object types. All fields are combined with a logical ‘and.’ */
-export type SpaceEditorCountFilter = {
+/** A filter to be used against `Relation` object types. All fields are combined with a logical ‘and.’ */
+export type RelationFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SpaceEditorCountFilter>>;
+  and?: Array<RelationFilter> | null | undefined;
+  /** Filter by the object’s `entity` relation. */
+  entity?: EntityFilter | null | undefined;
+  /** Filter by the object’s `entityId` field. */
+  entityId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `fromEntity` relation. */
+  fromEntity?: EntityFilter | null | undefined;
+  /** Filter by the object’s `fromEntityId` field. */
+  fromEntityId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `fromSpace` relation. */
+  fromSpace?: SpaceFilter | null | undefined;
+  /** A related `fromSpace` exists. */
+  fromSpaceExists?: boolean | null | undefined;
+  /** Filter by the object’s `fromSpaceId` field. */
+  fromSpaceId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `fromVersionId` field. */
+  fromVersionId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `id` field. */
+  id?: UuidFilter | null | undefined;
+  /** Filter by the object’s `isSystem` field. */
+  isSystem?: BooleanFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<SpaceEditorCountFilter>;
+  not?: RelationFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SpaceEditorCountFilter>>;
+  or?: Array<RelationFilter> | null | undefined;
+  /** Filter by the object’s `position` field. */
+  position?: StringFilter | null | undefined;
+  /** Filter by the object’s `space` relation. */
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `totalEditors` field. */
-  totalEditors?: InputMaybe<BigIntFilter>;
-};
-
-/** A connection to a list of `SpaceEditorCount` values. */
-export type SpaceEditorCountsConnection = {
-  __typename?: 'SpaceEditorCountsConnection';
-  /** A list of edges which contains the `SpaceEditorCount` and cursor to aid in pagination. */
-  edges: Array<SpaceEditorCountsEdge>;
-  /** A list of `SpaceEditorCount` objects. */
-  nodes: Array<SpaceEditorCount>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `SpaceEditorCount` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `SpaceEditorCount` edge in the connection. */
-export type SpaceEditorCountsEdge = {
-  __typename?: 'SpaceEditorCountsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `SpaceEditorCount` at the end of the edge. */
-  node: SpaceEditorCount;
+  spaceId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `toEntity` relation. */
+  toEntity?: EntityFilter | null | undefined;
+  /** Filter by the object’s `toEntityId` field. */
+  toEntityId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `toSpace` relation. */
+  toSpace?: SpaceFilter | null | undefined;
+  /** A related `toSpace` exists. */
+  toSpaceExists?: boolean | null | undefined;
+  /** Filter by the object’s `toSpaceId` field. */
+  toSpaceId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `toVersionId` field. */
+  toVersionId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `typeEntity` relation. */
+  typeEntity?: EntityFilter | null | undefined;
+  /** Filter by the object’s `typeId` field. */
+  typeId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `verified` field. */
+  verified?: BooleanFilter | null | undefined;
 };
 
-/** Methods to use when ordering `SpaceEditorCount`. */
-export enum SpaceEditorCountsOrderBy {
-  Natural = 'NATURAL',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  TotalEditorsAsc = 'TOTAL_EDITORS_ASC',
-  TotalEditorsDesc = 'TOTAL_EDITORS_DESC'
-}
-
 /** A filter to be used against `Space` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceFilter = {
   /** Filter by the object’s `address` field. */
-  address?: InputMaybe<StringFilter>;
+  address?: StringFilter | null | undefined;
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SpaceFilter>>;
+  and?: Array<SpaceFilter> | null | undefined;
   /** Filter by the object’s `editors` relation. */
-  editors?: InputMaybe<SpaceToManyEditorFilter>;
+  editors?: SpaceToManyEditorFilter | null | undefined;
   /** Some related `editors` exist. */
-  editorsExist?: InputMaybe<Scalars['Boolean']['input']>;
+  editorsExist?: boolean | null | undefined;
   /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
+  id?: UuidFilter | null | undefined;
   /** Filter by the object’s `members` relation. */
-  members?: InputMaybe<SpaceToManyMemberFilter>;
+  members?: SpaceToManyMemberFilter | null | undefined;
   /** Some related `members` exist. */
-  membersExist?: InputMaybe<Scalars['Boolean']['input']>;
+  membersExist?: boolean | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<SpaceFilter>;
+  not?: SpaceFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SpaceFilter>>;
+  or?: Array<SpaceFilter> | null | undefined;
   /** Filter by the object’s `proposalVotesConnection` relation. */
-  proposalVotesConnection?: InputMaybe<SpaceToManyProposalVoteFilter>;
+  proposalVotesConnection?: SpaceToManyProposalVoteFilter | null | undefined;
   /** Some related `proposalVotesConnection` exist. */
-  proposalVotesConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalVotesConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `proposalsConnection` relation. */
-  proposalsConnection?: InputMaybe<SpaceToManyProposalFilter>;
+  proposalsConnection?: SpaceToManyProposalFilter | null | undefined;
   /** Some related `proposalsConnection` exist. */
-  proposalsConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  proposalsConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `relationsByFromSpaceIdConnection` relation. */
-  relationsByFromSpaceIdConnection?: InputMaybe<SpaceToManyRelationFilter>;
+  relationsByFromSpaceIdConnection?: SpaceToManyRelationFilter | null | undefined;
   /** Some related `relationsByFromSpaceIdConnection` exist. */
-  relationsByFromSpaceIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsByFromSpaceIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `relationsByToSpaceIdConnection` relation. */
-  relationsByToSpaceIdConnection?: InputMaybe<SpaceToManyRelationFilter>;
+  relationsByToSpaceIdConnection?: SpaceToManyRelationFilter | null | undefined;
   /** Some related `relationsByToSpaceIdConnection` exist. */
-  relationsByToSpaceIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsByToSpaceIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `relationsConnection` relation. */
-  relationsConnection?: InputMaybe<SpaceToManyRelationFilter>;
+  relationsConnection?: SpaceToManyRelationFilter | null | undefined;
   /** Some related `relationsConnection` exist. */
-  relationsConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  relationsConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `spaceVotingSetting` relation. */
-  spaceVotingSetting?: InputMaybe<SpaceVotingSettingFilter>;
+  spaceVotingSetting?: SpaceVotingSettingFilter | null | undefined;
   /** A related `spaceVotingSetting` exists. */
-  spaceVotingSettingExists?: InputMaybe<Scalars['Boolean']['input']>;
+  spaceVotingSettingExists?: boolean | null | undefined;
   /** Filter by the object’s `subspaceTopicsConnection` relation. */
-  subspaceTopicsConnection?: InputMaybe<SpaceToManySubspaceTopicFilter>;
+  subspaceTopicsConnection?: SpaceToManySubspaceTopicFilter | null | undefined;
   /** Some related `subspaceTopicsConnection` exist. */
-  subspaceTopicsConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  subspaceTopicsConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `subspacesByChildSpaceIdConnection` relation. */
-  subspacesByChildSpaceIdConnection?: InputMaybe<SpaceToManySubspaceFilter>;
+  subspacesByChildSpaceIdConnection?: SpaceToManySubspaceFilter | null | undefined;
   /** Some related `subspacesByChildSpaceIdConnection` exist. */
-  subspacesByChildSpaceIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  subspacesByChildSpaceIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `subspacesByParentSpaceIdConnection` relation. */
-  subspacesByParentSpaceIdConnection?: InputMaybe<SpaceToManySubspaceFilter>;
+  subspacesByParentSpaceIdConnection?: SpaceToManySubspaceFilter | null | undefined;
   /** Some related `subspacesByParentSpaceIdConnection` exist. */
-  subspacesByParentSpaceIdConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
+  subspacesByParentSpaceIdConnectionExist?: boolean | null | undefined;
   /** Filter by the object’s `topic` relation. */
-  topic?: InputMaybe<EntityFilter>;
+  topic?: EntityFilter | null | undefined;
   /** A related `topic` exists. */
-  topicExists?: InputMaybe<Scalars['Boolean']['input']>;
+  topicExists?: boolean | null | undefined;
   /** Filter by the object’s `topicId` field. */
-  topicId?: InputMaybe<UuidFilter>;
+  topicId?: UuidFilter | null | undefined;
   /** Filter by the object’s `type` field. */
-  type?: InputMaybe<SpaceTypesFilter>;
+  type?: SpaceTypesFilter | null | undefined;
   /** Filter by the object’s `valuesConnection` relation. */
-  valuesConnection?: InputMaybe<SpaceToManyValueFilter>;
+  valuesConnection?: SpaceToManyValueFilter | null | undefined;
   /** Some related `valuesConnection` exist. */
-  valuesConnectionExist?: InputMaybe<Scalars['Boolean']['input']>;
-};
-
-export type SpaceScore = Node & {
-  __typename?: 'SpaceScore';
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  score: Scalars['BigFloat']['output'];
-  spaceId: Scalars['UUID']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `SpaceScore` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type SpaceScoreCondition = {
-  /** Checks for equality with the object’s `score` field. */
-  score?: InputMaybe<Scalars['BigFloat']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-};
-
-/** A filter to be used against `SpaceScore` object types. All fields are combined with a logical ‘and.’ */
-export type SpaceScoreFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SpaceScoreFilter>>;
-  /** Negates the expression. */
-  not?: InputMaybe<SpaceScoreFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SpaceScoreFilter>>;
-  /** Filter by the object’s `score` field. */
-  score?: InputMaybe<BigFloatFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `SpaceScore` values. */
-export type SpaceScoresConnection = {
-  __typename?: 'SpaceScoresConnection';
-  /** A list of edges which contains the `SpaceScore` and cursor to aid in pagination. */
-  edges: Array<SpaceScoresEdge>;
-  /** A list of `SpaceScore` objects. */
-  nodes: Array<SpaceScore>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `SpaceScore` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
+  valuesConnectionExist?: boolean | null | undefined;
 };
 
-/** A `SpaceScore` edge in the connection. */
-export type SpaceScoresEdge = {
-  __typename?: 'SpaceScoresEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `SpaceScore` at the end of the edge. */
-  node: SpaceScore;
-};
-
-/** Methods to use when ordering `SpaceScore`. */
-export enum SpaceScoresOrderBy {
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  ScoreAsc = 'SCORE_ASC',
-  ScoreDesc = 'SCORE_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
 /** A filter to be used against many `Editor` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyEditorFilter = {
   /** Every related `Editor` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<EditorFilter>;
+  every?: EditorFilter | null | undefined;
   /** No related `Editor` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<EditorFilter>;
+  none?: EditorFilter | null | undefined;
   /** Some related `Editor` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<EditorFilter>;
+  some?: EditorFilter | null | undefined;
 };
 
 /** A filter to be used against many `Member` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyMemberFilter = {
   /** Every related `Member` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<MemberFilter>;
+  every?: MemberFilter | null | undefined;
   /** No related `Member` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<MemberFilter>;
+  none?: MemberFilter | null | undefined;
   /** Some related `Member` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<MemberFilter>;
+  some?: MemberFilter | null | undefined;
 };
 
 /** A filter to be used against many `Proposal` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyProposalFilter = {
   /** Every related `Proposal` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ProposalFilter>;
+  every?: ProposalFilter | null | undefined;
   /** No related `Proposal` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ProposalFilter>;
+  none?: ProposalFilter | null | undefined;
   /** Some related `Proposal` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ProposalFilter>;
+  some?: ProposalFilter | null | undefined;
 };
 
 /** A filter to be used against many `ProposalVote` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyProposalVoteFilter = {
   /** Every related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ProposalVoteFilter>;
+  every?: ProposalVoteFilter | null | undefined;
   /** No related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ProposalVoteFilter>;
+  none?: ProposalVoteFilter | null | undefined;
   /** Some related `ProposalVote` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ProposalVoteFilter>;
+  some?: ProposalVoteFilter | null | undefined;
 };
 
 /** A filter to be used against many `Relation` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyRelationFilter = {
   /** Every related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<RelationFilter>;
+  every?: RelationFilter | null | undefined;
   /** No related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<RelationFilter>;
+  none?: RelationFilter | null | undefined;
   /** Some related `Relation` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<RelationFilter>;
+  some?: RelationFilter | null | undefined;
 };
 
 /** A filter to be used against many `Subspace` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManySubspaceFilter = {
   /** Every related `Subspace` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<SubspaceFilter>;
+  every?: SubspaceFilter | null | undefined;
   /** No related `Subspace` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<SubspaceFilter>;
+  none?: SubspaceFilter | null | undefined;
   /** Some related `Subspace` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<SubspaceFilter>;
+  some?: SubspaceFilter | null | undefined;
 };
 
 /** A filter to be used against many `SubspaceTopic` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManySubspaceTopicFilter = {
   /** Every related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<SubspaceTopicFilter>;
+  every?: SubspaceTopicFilter | null | undefined;
   /** No related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<SubspaceTopicFilter>;
+  none?: SubspaceTopicFilter | null | undefined;
   /** Some related `SubspaceTopic` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<SubspaceTopicFilter>;
+  some?: SubspaceTopicFilter | null | undefined;
 };
 
 /** A filter to be used against many `Value` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceToManyValueFilter = {
   /** Every related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  every?: InputMaybe<ValueFilter>;
+  every?: ValueFilter | null | undefined;
   /** No related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  none?: InputMaybe<ValueFilter>;
+  none?: ValueFilter | null | undefined;
   /** Some related `Value` matches the filter criteria. All fields are combined with a logical ‘and.’ */
-  some?: InputMaybe<ValueFilter>;
+  some?: ValueFilter | null | undefined;
 };
 
 export enum SpaceTypes {
@@ -5345,430 +808,177 @@ export enum SpaceTypes {
 /** A filter to be used against SpaceTypes fields. All fields are combined with a logical ‘and.’ */
 export type SpaceTypesFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<SpaceTypes>;
+  distinctFrom?: SpaceTypes | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<SpaceTypes>;
+  greaterThan?: SpaceTypes | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<SpaceTypes>;
+  greaterThanOrEqualTo?: SpaceTypes | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<SpaceTypes>>;
+  in?: Array<SpaceTypes> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<SpaceTypes>;
+  is?: SpaceTypes | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<SpaceTypes>;
+  isNot?: SpaceTypes | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<SpaceTypes>;
+  lessThan?: SpaceTypes | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<SpaceTypes>;
+  lessThanOrEqualTo?: SpaceTypes | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<SpaceTypes>;
+  notDistinctFrom?: SpaceTypes | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<SpaceTypes>>;
-};
-
-export type SpaceVotingSetting = Node & {
-  __typename?: 'SpaceVotingSetting';
-  disableFastPathAccessForNewMembers: Scalars['Boolean']['output'];
-  duration: Scalars['BigInt']['output'];
-  executionGracePeriod: Scalars['BigInt']['output'];
-  flatSupportThreshold: Scalars['BigInt']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  partialPercentageSupportThreshold: Scalars['BigInt']['output'];
-  quorum: Scalars['BigInt']['output'];
-  /** Reads a single `Space` that is related to this `SpaceVotingSetting`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-  universalPercentageSupportThreshold: Scalars['BigInt']['output'];
-  updatedAt: Scalars['String']['output'];
-  updatedAtBlock: Scalars['String']['output'];
-};
-
-/**
- * A condition to be used against `SpaceVotingSetting` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type SpaceVotingSettingCondition = {
-  /** Checks for equality with the object’s `disableFastPathAccessForNewMembers` field. */
-  disableFastPathAccessForNewMembers?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for equality with the object’s `duration` field. */
-  duration?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `executionGracePeriod` field. */
-  executionGracePeriod?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `quorum` field. */
-  quorum?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `updatedAtBlock` field. */
-  updatedAtBlock?: InputMaybe<Scalars['String']['input']>;
+  notIn?: Array<SpaceTypes> | null | undefined;
 };
 
 /** A filter to be used against `SpaceVotingSetting` object types. All fields are combined with a logical ‘and.’ */
 export type SpaceVotingSettingFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SpaceVotingSettingFilter>>;
+  and?: Array<SpaceVotingSettingFilter> | null | undefined;
   /** Filter by the object’s `disableFastPathAccessForNewMembers` field. */
-  disableFastPathAccessForNewMembers?: InputMaybe<BooleanFilter>;
+  disableFastPathAccessForNewMembers?: BooleanFilter | null | undefined;
   /** Filter by the object’s `duration` field. */
-  duration?: InputMaybe<BigIntFilter>;
+  duration?: BigIntFilter | null | undefined;
   /** Filter by the object’s `executionGracePeriod` field. */
-  executionGracePeriod?: InputMaybe<BigIntFilter>;
+  executionGracePeriod?: BigIntFilter | null | undefined;
   /** Filter by the object’s `flatSupportThreshold` field. */
-  flatSupportThreshold?: InputMaybe<BigIntFilter>;
+  flatSupportThreshold?: BigIntFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<SpaceVotingSettingFilter>;
+  not?: SpaceVotingSettingFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SpaceVotingSettingFilter>>;
+  or?: Array<SpaceVotingSettingFilter> | null | undefined;
   /** Filter by the object’s `partialPercentageSupportThreshold` field. */
-  partialPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
+  partialPercentageSupportThreshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `quorum` field. */
-  quorum?: InputMaybe<BigIntFilter>;
+  quorum?: BigIntFilter | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
+  spaceId?: UuidFilter | null | undefined;
   /** Filter by the object’s `universalPercentageSupportThreshold` field. */
-  universalPercentageSupportThreshold?: InputMaybe<BigIntFilter>;
+  universalPercentageSupportThreshold?: BigIntFilter | null | undefined;
   /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<StringFilter>;
+  updatedAt?: StringFilter | null | undefined;
   /** Filter by the object’s `updatedAtBlock` field. */
-  updatedAtBlock?: InputMaybe<StringFilter>;
-};
-
-/** A connection to a list of `SpaceVotingSetting` values. */
-export type SpaceVotingSettingsConnection = {
-  __typename?: 'SpaceVotingSettingsConnection';
-  /** A list of edges which contains the `SpaceVotingSetting` and cursor to aid in pagination. */
-  edges: Array<SpaceVotingSettingsEdge>;
-  /** A list of `SpaceVotingSetting` objects. */
-  nodes: Array<SpaceVotingSetting>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `SpaceVotingSetting` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `SpaceVotingSetting` edge in the connection. */
-export type SpaceVotingSettingsEdge = {
-  __typename?: 'SpaceVotingSettingsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `SpaceVotingSetting` at the end of the edge. */
-  node: SpaceVotingSetting;
-};
-
-/** Methods to use when ordering `SpaceVotingSetting`. */
-export enum SpaceVotingSettingsOrderBy {
-  DisableFastPathAccessForNewMembersAsc = 'DISABLE_FAST_PATH_ACCESS_FOR_NEW_MEMBERS_ASC',
-  DisableFastPathAccessForNewMembersDesc = 'DISABLE_FAST_PATH_ACCESS_FOR_NEW_MEMBERS_DESC',
-  DurationAsc = 'DURATION_ASC',
-  DurationDesc = 'DURATION_DESC',
-  ExecutionGracePeriodAsc = 'EXECUTION_GRACE_PERIOD_ASC',
-  ExecutionGracePeriodDesc = 'EXECUTION_GRACE_PERIOD_DESC',
-  FlatSupportThresholdAsc = 'FLAT_SUPPORT_THRESHOLD_ASC',
-  FlatSupportThresholdDesc = 'FLAT_SUPPORT_THRESHOLD_DESC',
-  Natural = 'NATURAL',
-  PartialPercentageSupportThresholdAsc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  PartialPercentageSupportThresholdDesc = 'PARTIAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  QuorumAsc = 'QUORUM_ASC',
-  QuorumDesc = 'QUORUM_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UniversalPercentageSupportThresholdAsc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_ASC',
-  UniversalPercentageSupportThresholdDesc = 'UNIVERSAL_PERCENTAGE_SUPPORT_THRESHOLD_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtBlockAsc = 'UPDATED_AT_BLOCK_ASC',
-  UpdatedAtBlockDesc = 'UPDATED_AT_BLOCK_DESC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC'
-}
-
-/** A connection to a list of `Space` values. */
-export type SpacesConnection = {
-  __typename?: 'SpacesConnection';
-  /** A list of edges which contains the `Space` and cursor to aid in pagination. */
-  edges: Array<SpacesEdge>;
-  /** A list of `Space` objects. */
-  nodes: Array<Space>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Space` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
+  updatedAtBlock?: StringFilter | null | undefined;
 };
 
-/** A `Space` edge in the connection. */
-export type SpacesEdge = {
-  __typename?: 'SpacesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Space` at the end of the edge. */
-  node: Space;
-};
-
-/** Methods to use when ordering `Space`. */
-export enum SpacesOrderBy {
-  AddressAsc = 'ADDRESS_ASC',
-  AddressDesc = 'ADDRESS_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  TopicIdAsc = 'TOPIC_ID_ASC',
-  TopicIdDesc = 'TOPIC_ID_DESC',
-  TypeAsc = 'TYPE_ASC',
-  TypeDesc = 'TYPE_DESC'
-}
-
 /** A filter to be used against String fields. All fields are combined with a logical ‘and.’ */
 export type StringFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['String']['input']>;
+  distinctFrom?: string | null | undefined;
   /** Not equal to the specified value, treating null like an ordinary value (case-insensitive). */
-  distinctFromInsensitive?: InputMaybe<Scalars['String']['input']>;
+  distinctFromInsensitive?: string | null | undefined;
   /** Ends with the specified string (case-sensitive). */
-  endsWith?: InputMaybe<Scalars['String']['input']>;
+  endsWith?: string | null | undefined;
   /** Ends with the specified string (case-insensitive). */
-  endsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
+  endsWithInsensitive?: string | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['String']['input']>;
+  greaterThan?: string | null | undefined;
   /** Greater than the specified value (case-insensitive). */
-  greaterThanInsensitive?: InputMaybe<Scalars['String']['input']>;
+  greaterThanInsensitive?: string | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
+  greaterThanOrEqualTo?: string | null | undefined;
   /** Greater than or equal to the specified value (case-insensitive). */
-  greaterThanOrEqualToInsensitive?: InputMaybe<Scalars['String']['input']>;
+  greaterThanOrEqualToInsensitive?: string | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['String']['input']>>;
+  in?: Array<string> | null | undefined;
   /** Included in the specified list (case-insensitive). */
-  inInsensitive?: InputMaybe<Array<Scalars['String']['input']>>;
+  inInsensitive?: Array<string> | null | undefined;
   /** Contains the specified string (case-sensitive). */
-  includes?: InputMaybe<Scalars['String']['input']>;
+  includes?: string | null | undefined;
   /** Contains the specified string (case-insensitive). */
-  includesInsensitive?: InputMaybe<Scalars['String']['input']>;
+  includesInsensitive?: string | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['String']['input']>;
+  is?: string | null | undefined;
   /** Equal to the specified value (case-insensitive). */
-  isInsensitive?: InputMaybe<Scalars['String']['input']>;
+  isInsensitive?: string | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['String']['input']>;
+  isNot?: string | null | undefined;
   /** Not equal to the specified value (case-insensitive). */
-  isNotInsensitive?: InputMaybe<Scalars['String']['input']>;
+  isNotInsensitive?: string | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['String']['input']>;
+  lessThan?: string | null | undefined;
   /** Less than the specified value (case-insensitive). */
-  lessThanInsensitive?: InputMaybe<Scalars['String']['input']>;
+  lessThanInsensitive?: string | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
+  lessThanOrEqualTo?: string | null | undefined;
   /** Less than or equal to the specified value (case-insensitive). */
-  lessThanOrEqualToInsensitive?: InputMaybe<Scalars['String']['input']>;
+  lessThanOrEqualToInsensitive?: string | null | undefined;
   /** Matches the specified pattern (case-sensitive). An underscore (_) matches any single character; a percent sign (%) matches any sequence of zero or more characters. */
-  like?: InputMaybe<Scalars['String']['input']>;
+  like?: string | null | undefined;
   /** Matches the specified pattern (case-insensitive). An underscore (_) matches any single character; a percent sign (%) matches any sequence of zero or more characters. */
-  likeInsensitive?: InputMaybe<Scalars['String']['input']>;
+  likeInsensitive?: string | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['String']['input']>;
+  notDistinctFrom?: string | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value (case-insensitive). */
-  notDistinctFromInsensitive?: InputMaybe<Scalars['String']['input']>;
+  notDistinctFromInsensitive?: string | null | undefined;
   /** Does not end with the specified string (case-sensitive). */
-  notEndsWith?: InputMaybe<Scalars['String']['input']>;
+  notEndsWith?: string | null | undefined;
   /** Does not end with the specified string (case-insensitive). */
-  notEndsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
+  notEndsWithInsensitive?: string | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['String']['input']>>;
+  notIn?: Array<string> | null | undefined;
   /** Not included in the specified list (case-insensitive). */
-  notInInsensitive?: InputMaybe<Array<Scalars['String']['input']>>;
+  notInInsensitive?: Array<string> | null | undefined;
   /** Does not contain the specified string (case-sensitive). */
-  notIncludes?: InputMaybe<Scalars['String']['input']>;
+  notIncludes?: string | null | undefined;
   /** Does not contain the specified string (case-insensitive). */
-  notIncludesInsensitive?: InputMaybe<Scalars['String']['input']>;
+  notIncludesInsensitive?: string | null | undefined;
   /** Does not match the specified pattern (case-sensitive). An underscore (_) matches any single character; a percent sign (%) matches any sequence of zero or more characters. */
-  notLike?: InputMaybe<Scalars['String']['input']>;
+  notLike?: string | null | undefined;
   /** Does not match the specified pattern (case-insensitive). An underscore (_) matches any single character; a percent sign (%) matches any sequence of zero or more characters. */
-  notLikeInsensitive?: InputMaybe<Scalars['String']['input']>;
+  notLikeInsensitive?: string | null | undefined;
   /** Does not start with the specified string (case-sensitive). */
-  notStartsWith?: InputMaybe<Scalars['String']['input']>;
+  notStartsWith?: string | null | undefined;
   /** Does not start with the specified string (case-insensitive). */
-  notStartsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
+  notStartsWithInsensitive?: string | null | undefined;
   /** Starts with the specified string (case-sensitive). */
-  startsWith?: InputMaybe<Scalars['String']['input']>;
+  startsWith?: string | null | undefined;
   /** Starts with the specified string (case-insensitive). */
-  startsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
-};
-
-/** A filter to be used against String List fields. All fields are combined with a logical ‘and.’ */
-export type StringListFilter = {
-  /** Any array item is equal to the specified value. */
-  anyEqualTo?: InputMaybe<Scalars['String']['input']>;
-  /** Any array item is greater than the specified value. */
-  anyGreaterThan?: InputMaybe<Scalars['String']['input']>;
-  /** Any array item is greater than or equal to the specified value. */
-  anyGreaterThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
-  /** Any array item is less than the specified value. */
-  anyLessThan?: InputMaybe<Scalars['String']['input']>;
-  /** Any array item is less than or equal to the specified value. */
-  anyLessThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
-  /** Any array item is not equal to the specified value. */
-  anyNotEqualTo?: InputMaybe<Scalars['String']['input']>;
-  /** Contained by the specified list of values. */
-  containedBy?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Contains the specified list of values. */
-  in?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Equal to the specified value. */
-  is?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Not equal to the specified value. */
-  isNot?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Less than the specified value. */
-  lessThan?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  /** Overlaps the specified list of values. */
-  overlaps?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-};
-
-export type Subspace = Node & {
-  __typename?: 'Subspace';
-  /** Reads a single `Space` that is related to this `Subspace`. */
-  childSpace?: Maybe<Space>;
-  childSpaceId: Scalars['UUID']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `Space` that is related to this `Subspace`. */
-  parentSpace?: Maybe<Space>;
-  parentSpaceId: Scalars['UUID']['output'];
-  type: SubspaceType;
-};
-
-/**
- * A condition to be used against `Subspace` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type SubspaceCondition = {
-  /** Checks for equality with the object’s `childSpaceId` field. */
-  childSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `parentSpaceId` field. */
-  parentSpaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `type` field. */
-  type?: InputMaybe<SubspaceType>;
+  startsWithInsensitive?: string | null | undefined;
 };
 
 /** A filter to be used against `Subspace` object types. All fields are combined with a logical ‘and.’ */
 export type SubspaceFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SubspaceFilter>>;
+  and?: Array<SubspaceFilter> | null | undefined;
   /** Filter by the object’s `childSpace` relation. */
-  childSpace?: InputMaybe<SpaceFilter>;
+  childSpace?: SpaceFilter | null | undefined;
   /** Filter by the object’s `childSpaceId` field. */
-  childSpaceId?: InputMaybe<UuidFilter>;
+  childSpaceId?: UuidFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<SubspaceFilter>;
+  not?: SubspaceFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SubspaceFilter>>;
+  or?: Array<SubspaceFilter> | null | undefined;
   /** Filter by the object’s `parentSpace` relation. */
-  parentSpace?: InputMaybe<SpaceFilter>;
+  parentSpace?: SpaceFilter | null | undefined;
   /** Filter by the object’s `parentSpaceId` field. */
-  parentSpaceId?: InputMaybe<UuidFilter>;
+  parentSpaceId?: UuidFilter | null | undefined;
   /** Filter by the object’s `type` field. */
-  type?: InputMaybe<SubspaceTypeFilter>;
-};
-
-export type SubspaceTopic = Node & {
-  __typename?: 'SubspaceTopic';
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  /** Reads a single `Space` that is related to this `SubspaceTopic`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-  /** Reads a single `Entity` that is related to this `SubspaceTopic`. */
-  topic?: Maybe<Entity>;
-  topicId: Scalars['UUID']['output'];
-};
-
-/**
- * A condition to be used against `SubspaceTopic` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type SubspaceTopicCondition = {
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `topicId` field. */
-  topicId?: InputMaybe<Scalars['UUID']['input']>;
+  type?: SubspaceTypeFilter | null | undefined;
 };
 
 /** A filter to be used against `SubspaceTopic` object types. All fields are combined with a logical ‘and.’ */
 export type SubspaceTopicFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<SubspaceTopicFilter>>;
+  and?: Array<SubspaceTopicFilter> | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<SubspaceTopicFilter>;
+  not?: SubspaceTopicFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<SubspaceTopicFilter>>;
+  or?: Array<SubspaceTopicFilter> | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
+  spaceId?: UuidFilter | null | undefined;
   /** Filter by the object’s `topic` relation. */
-  topic?: InputMaybe<EntityFilter>;
+  topic?: EntityFilter | null | undefined;
   /** Filter by the object’s `topicId` field. */
-  topicId?: InputMaybe<UuidFilter>;
-};
-
-/** A connection to a list of `SubspaceTopic` values. */
-export type SubspaceTopicsConnection = {
-  __typename?: 'SubspaceTopicsConnection';
-  /** A list of edges which contains the `SubspaceTopic` and cursor to aid in pagination. */
-  edges: Array<SubspaceTopicsEdge>;
-  /** A list of `SubspaceTopic` objects. */
-  nodes: Array<SubspaceTopic>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `SubspaceTopic` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `SubspaceTopic` edge in the connection. */
-export type SubspaceTopicsEdge = {
-  __typename?: 'SubspaceTopicsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `SubspaceTopic` at the end of the edge. */
-  node: SubspaceTopic;
+  topicId?: UuidFilter | null | undefined;
 };
 
-/** Methods to use when ordering `SubspaceTopic`. */
-export enum SubspaceTopicsOrderBy {
-  Natural = 'NATURAL',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  TopicIdAsc = 'TOPIC_ID_ASC',
-  TopicIdDesc = 'TOPIC_ID_DESC'
-}
-
 export enum SubspaceType {
   Related = 'RELATED',
   Verified = 'VERIFIED'
@@ -5777,754 +987,199 @@ export enum SubspaceType {
 /** A filter to be used against SubspaceType fields. All fields are combined with a logical ‘and.’ */
 export type SubspaceTypeFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<SubspaceType>;
+  distinctFrom?: SubspaceType | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<SubspaceType>;
+  greaterThan?: SubspaceType | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<SubspaceType>;
+  greaterThanOrEqualTo?: SubspaceType | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<SubspaceType>>;
+  in?: Array<SubspaceType> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<SubspaceType>;
+  is?: SubspaceType | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<SubspaceType>;
+  isNot?: SubspaceType | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<SubspaceType>;
+  lessThan?: SubspaceType | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<SubspaceType>;
+  lessThanOrEqualTo?: SubspaceType | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<SubspaceType>;
+  notDistinctFrom?: SubspaceType | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<SubspaceType>>;
-};
-
-/** A connection to a list of `Subspace` values. */
-export type SubspacesConnection = {
-  __typename?: 'SubspacesConnection';
-  /** A list of edges which contains the `Subspace` and cursor to aid in pagination. */
-  edges: Array<SubspacesEdge>;
-  /** A list of `Subspace` objects. */
-  nodes: Array<Subspace>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Subspace` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
+  notIn?: Array<SubspaceType> | null | undefined;
 };
 
-/** A `Subspace` edge in the connection. */
-export type SubspacesEdge = {
-  __typename?: 'SubspacesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Subspace` at the end of the edge. */
-  node: Subspace;
-};
-
-/** Methods to use when ordering `Subspace`. */
-export enum SubspacesOrderBy {
-  ChildSpaceIdAsc = 'CHILD_SPACE_ID_ASC',
-  ChildSpaceIdDesc = 'CHILD_SPACE_ID_DESC',
-  Natural = 'NATURAL',
-  ParentSpaceIdAsc = 'PARENT_SPACE_ID_ASC',
-  ParentSpaceIdDesc = 'PARENT_SPACE_ID_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  TypeAsc = 'TYPE_ASC',
-  TypeDesc = 'TYPE_DESC'
-}
-
 /** A filter to be used against Time fields. All fields are combined with a logical ‘and.’ */
 export type TimeFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['Time']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['Time']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Time']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['Time']['input']>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['Time']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['Time']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['Time']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['Time']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['Time']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['Time']['input']>>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against UUID fields. All fields are combined with a logical ‘and.’ */
 export type UuidFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Scalars['UUID']['input']>;
+  distinctFrom?: any;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Scalars['UUID']['input']>;
+  greaterThan?: any;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  greaterThanOrEqualTo?: any;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<Scalars['UUID']['input']>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Scalars['UUID']['input']>;
+  is?: any;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Scalars['UUID']['input']>;
+  isNot?: any;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Scalars['UUID']['input']>;
+  lessThan?: any;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  lessThanOrEqualTo?: any;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Scalars['UUID']['input']>;
+  notDistinctFrom?: any;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<Scalars['UUID']['input']>>;
+  notIn?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against UUID List fields. All fields are combined with a logical ‘and.’ */
 export type UuidListFilter = {
   /** Any array item is equal to the specified value. */
-  anyEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  anyEqualTo?: any;
   /** Any array item is greater than the specified value. */
-  anyGreaterThan?: InputMaybe<Scalars['UUID']['input']>;
+  anyGreaterThan?: any;
   /** Any array item is greater than or equal to the specified value. */
-  anyGreaterThanOrEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  anyGreaterThanOrEqualTo?: any;
   /** Any array item is less than the specified value. */
-  anyLessThan?: InputMaybe<Scalars['UUID']['input']>;
+  anyLessThan?: any;
   /** Any array item is less than or equal to the specified value. */
-  anyLessThanOrEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  anyLessThanOrEqualTo?: any;
   /** Any array item is not equal to the specified value. */
-  anyNotEqualTo?: InputMaybe<Scalars['UUID']['input']>;
+  anyNotEqualTo?: any;
   /** Contained by the specified list of values. */
-  containedBy?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  containedBy?: Array<any> | null | undefined;
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  distinctFrom?: Array<any> | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  greaterThan?: Array<any> | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  greaterThanOrEqualTo?: Array<any> | null | undefined;
   /** Contains the specified list of values. */
-  in?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  in?: Array<any> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  is?: Array<any> | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  isNot?: Array<any> | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  lessThan?: Array<any> | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  lessThanOrEqualTo?: Array<any> | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
+  notDistinctFrom?: Array<any> | null | undefined;
   /** Overlaps the specified list of values. */
-  overlaps?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
-};
-
-export type UserVote = {
-  __typename?: 'UserVote';
-  objectId: Scalars['UUID']['output'];
-  objectType: Scalars['Int']['output'];
-  spaceId: Scalars['UUID']['output'];
-  userId: Scalars['UUID']['output'];
-  voteType: Scalars['Int']['output'];
-  votedAt: Scalars['Datetime']['output'];
-};
-
-/**
- * A condition to be used against `UserVote` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type UserVoteCondition = {
-  /** Checks for equality with the object’s `objectId` field. */
-  objectId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `objectType` field. */
-  objectType?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `userId` field. */
-  userId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `voteType` field. */
-  voteType?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `votedAt` field. */
-  votedAt?: InputMaybe<Scalars['Datetime']['input']>;
+  overlaps?: Array<any> | null | undefined;
 };
 
 /** A filter to be used against `UserVote` object types. All fields are combined with a logical ‘and.’ */
 export type UserVoteFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<UserVoteFilter>>;
+  and?: Array<UserVoteFilter> | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<UserVoteFilter>;
+  not?: UserVoteFilter | null | undefined;
   /** Filter by the object’s `objectId` field. */
-  objectId?: InputMaybe<UuidFilter>;
+  objectId?: UuidFilter | null | undefined;
   /** Filter by the object’s `objectType` field. */
-  objectType?: InputMaybe<IntFilter>;
+  objectType?: IntFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<UserVoteFilter>>;
+  or?: Array<UserVoteFilter> | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
+  spaceId?: UuidFilter | null | undefined;
   /** Filter by the object’s `userId` field. */
-  userId?: InputMaybe<UuidFilter>;
+  userId?: UuidFilter | null | undefined;
+  /** Filter by the object’s `voteKind` field. */
+  voteKind?: IntFilter | null | undefined;
   /** Filter by the object’s `voteType` field. */
-  voteType?: InputMaybe<IntFilter>;
+  voteType?: IntFilter | null | undefined;
   /** Filter by the object’s `votedAt` field. */
-  votedAt?: InputMaybe<DatetimeFilter>;
-};
-
-/** A connection to a list of `UserVote` values. */
-export type UserVotesConnection = {
-  __typename?: 'UserVotesConnection';
-  /** A list of edges which contains the `UserVote` and cursor to aid in pagination. */
-  edges: Array<UserVotesEdge>;
-  /** A list of `UserVote` objects. */
-  nodes: Array<UserVote>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `UserVote` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `UserVote` edge in the connection. */
-export type UserVotesEdge = {
-  __typename?: 'UserVotesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `UserVote` at the end of the edge. */
-  node: UserVote;
-};
-
-/** Methods to use when ordering `UserVote`. */
-export enum UserVotesOrderBy {
-  Natural = 'NATURAL',
-  ObjectIdAsc = 'OBJECT_ID_ASC',
-  ObjectIdDesc = 'OBJECT_ID_DESC',
-  ObjectTypeAsc = 'OBJECT_TYPE_ASC',
-  ObjectTypeDesc = 'OBJECT_TYPE_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UserIdAsc = 'USER_ID_ASC',
-  UserIdDesc = 'USER_ID_DESC',
-  VotedAtAsc = 'VOTED_AT_ASC',
-  VotedAtDesc = 'VOTED_AT_DESC',
-  VoteTypeAsc = 'VOTE_TYPE_ASC',
-  VoteTypeDesc = 'VOTE_TYPE_DESC'
-}
-
-export type Value = Node & {
-  __typename?: 'Value';
-  boolean?: Maybe<Scalars['Boolean']['output']>;
-  bytes?: Maybe<Scalars['Bytes']['output']>;
-  date?: Maybe<Scalars['DateString']['output']>;
-  datetime?: Maybe<Scalars['DateTimeString']['output']>;
-  datetimeUtc?: Maybe<Scalars['Datetime']['output']>;
-  decimal?: Maybe<Scalars['BigFloat']['output']>;
-  embedding?: Maybe<Scalars['JSON']['output']>;
-  /** Reads a single `Entity` that is related to this `Value`. */
-  entity?: Maybe<Entity>;
-  entityId: Scalars['UUID']['output'];
-  float?: Maybe<Scalars['Float']['output']>;
-  id: Scalars['String']['output'];
-  integer?: Maybe<Scalars['BigInt']['output']>;
-  language?: Maybe<Scalars['LanguageTag']['output']>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  point?: Maybe<Scalars['GeoPoint']['output']>;
-  property?: Maybe<PropertyInfo>;
-  /** Reads a single `Entity` that is related to this `Value`. */
-  propertyEntity?: Maybe<Entity>;
-  propertyId: Scalars['UUID']['output'];
-  rect?: Maybe<Scalars['GeoRect']['output']>;
-  schedule?: Maybe<Scalars['JSON']['output']>;
-  /** Reads a single `Space` that is related to this `Value`. */
-  space?: Maybe<Space>;
-  spaceId: Scalars['UUID']['output'];
-  text?: Maybe<Scalars['String']['output']>;
-  time?: Maybe<Scalars['TimeString']['output']>;
-  timeUtc?: Maybe<Scalars['Time']['output']>;
-  unit?: Maybe<Scalars['String']['output']>;
-};
-
-/** A condition to be used against `Value` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type ValueCondition = {
-  /** Checks for equality with the object’s `boolean` field. */
-  boolean?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for equality with the object’s `bytes` field. */
-  bytes?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `date` field. */
-  date?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `datetime` field. */
-  datetime?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `datetimeUtc` field. */
-  datetimeUtc?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `decimal` field. */
-  decimal?: InputMaybe<Scalars['BigFloat']['input']>;
-  /** Checks for equality with the object’s `embedding` field. */
-  embedding?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `float` field. */
-  float?: InputMaybe<Scalars['Float']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `integer` field. */
-  integer?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `language` field. */
-  language?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `point` field. */
-  point?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `propertyId` field. */
-  propertyId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `rect` field. */
-  rect?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `schedule` field. */
-  schedule?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `text` field. */
-  text?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `time` field. */
-  time?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `timeUtc` field. */
-  timeUtc?: InputMaybe<Scalars['Time']['input']>;
-  /** Checks for equality with the object’s `unit` field. */
-  unit?: InputMaybe<Scalars['String']['input']>;
+  votedAt?: DatetimeFilter | null | undefined;
 };
 
 /** A filter to be used against `Value` object types. All fields are combined with a logical ‘and.’ */
 export type ValueFilter = {
   /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ValueFilter>>;
+  and?: Array<ValueFilter> | null | undefined;
   /** Filter by the object’s `boolean` field. */
-  boolean?: InputMaybe<BooleanFilter>;
+  boolean?: BooleanFilter | null | undefined;
   /** Filter by the object’s `date` field. */
-  date?: InputMaybe<StringFilter>;
+  date?: StringFilter | null | undefined;
   /** Filter by the object’s `datetime` field. */
-  datetime?: InputMaybe<StringFilter>;
+  datetime?: StringFilter | null | undefined;
   /** Filter by the object’s `datetimeUtc` field. */
-  datetimeUtc?: InputMaybe<DatetimeFilter>;
+  datetimeUtc?: DatetimeFilter | null | undefined;
   /** Filter by the object’s `decimal` field. */
-  decimal?: InputMaybe<BigFloatFilter>;
+  decimal?: BigFloatFilter | null | undefined;
   /** Filter by the object’s `embedding` field. */
-  embedding?: InputMaybe<JsonFilter>;
+  embedding?: JsonFilter | null | undefined;
   /** Filter by the object’s `entity` relation. */
-  entity?: InputMaybe<EntityFilter>;
+  entity?: EntityFilter | null | undefined;
   /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
+  entityId?: UuidFilter | null | undefined;
   /** Filter by the object’s `float` field. */
-  float?: InputMaybe<FloatFilter>;
+  float?: FloatFilter | null | undefined;
   /** Filter by the object’s `id` field. */
-  id?: InputMaybe<StringFilter>;
+  id?: StringFilter | null | undefined;
   /** Filter by the object’s `integer` field. */
-  integer?: InputMaybe<BigIntFilter>;
+  integer?: BigIntFilter | null | undefined;
   /** Filter by the object’s `language` field. */
-  language?: InputMaybe<StringFilter>;
+  language?: StringFilter | null | undefined;
   /** Negates the expression. */
-  not?: InputMaybe<ValueFilter>;
+  not?: ValueFilter | null | undefined;
   /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ValueFilter>>;
+  or?: Array<ValueFilter> | null | undefined;
   /** Filter by the object’s `point` field. */
-  point?: InputMaybe<StringFilter>;
+  point?: StringFilter | null | undefined;
   /** Filter by the object’s `propertyEntity` relation. */
-  propertyEntity?: InputMaybe<EntityFilter>;
+  propertyEntity?: EntityFilter | null | undefined;
   /** Filter by the object’s `propertyId` field. */
-  propertyId?: InputMaybe<UuidFilter>;
+  propertyId?: UuidFilter | null | undefined;
   /** Filter by the object’s `rect` field. */
-  rect?: InputMaybe<StringFilter>;
+  rect?: StringFilter | null | undefined;
   /** Filter by the object’s `schedule` field. */
-  schedule?: InputMaybe<JsonFilter>;
+  schedule?: JsonFilter | null | undefined;
   /** Filter by the object’s `space` relation. */
-  space?: InputMaybe<SpaceFilter>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `text` field. */
-  text?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `time` field. */
-  time?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `timeUtc` field. */
-  timeUtc?: InputMaybe<TimeFilter>;
-  /** Filter by the object’s `unit` field. */
-  unit?: InputMaybe<StringFilter>;
-};
-
-export type ValueVersion = Node & {
-  __typename?: 'ValueVersion';
-  boolean?: Maybe<Scalars['Boolean']['output']>;
-  bytes?: Maybe<Scalars['Bytes']['output']>;
-  contextEdgeTypeId?: Maybe<Scalars['UUID']['output']>;
-  contextLastToEntityId?: Maybe<Scalars['UUID']['output']>;
-  contextRootId?: Maybe<Scalars['UUID']['output']>;
-  date?: Maybe<Scalars['DateString']['output']>;
-  datetime?: Maybe<Scalars['DateTimeString']['output']>;
-  datetimeUtc?: Maybe<Scalars['Datetime']['output']>;
-  decimal?: Maybe<Scalars['BigFloat']['output']>;
-  embedding?: Maybe<Scalars['JSON']['output']>;
-  entityId: Scalars['UUID']['output'];
-  float?: Maybe<Scalars['Float']['output']>;
-  id: Scalars['UUID']['output'];
-  integer?: Maybe<Scalars['BigInt']['output']>;
-  language?: Maybe<Scalars['LanguageTag']['output']>;
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  point?: Maybe<Scalars['GeoPoint']['output']>;
-  propertyId: Scalars['UUID']['output'];
-  rect?: Maybe<Scalars['GeoRect']['output']>;
-  schedule?: Maybe<Scalars['JSON']['output']>;
-  spaceId: Scalars['UUID']['output'];
-  text?: Maybe<Scalars['String']['output']>;
-  time?: Maybe<Scalars['TimeString']['output']>;
-  timeUtc?: Maybe<Scalars['Time']['output']>;
-  unit?: Maybe<Scalars['String']['output']>;
-  validFromKey: Scalars['BigInt']['output'];
-  validToKey?: Maybe<Scalars['BigInt']['output']>;
-};
-
-/**
- * A condition to be used against `ValueVersion` object types. All fields are
- * tested for equality and combined with a logical ‘and.’
- */
-export type ValueVersionCondition = {
-  /** Checks for equality with the object’s `boolean` field. */
-  boolean?: InputMaybe<Scalars['Boolean']['input']>;
-  /** Checks for equality with the object’s `bytes` field. */
-  bytes?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `contextEdgeTypeId` field. */
-  contextEdgeTypeId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `contextLastToEntityId` field. */
-  contextLastToEntityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `contextRootId` field. */
-  contextRootId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `date` field. */
-  date?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `datetime` field. */
-  datetime?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `datetimeUtc` field. */
-  datetimeUtc?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `decimal` field. */
-  decimal?: InputMaybe<Scalars['BigFloat']['input']>;
-  /** Checks for equality with the object’s `embedding` field. */
-  embedding?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `entityId` field. */
-  entityId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `float` field. */
-  float?: InputMaybe<Scalars['Float']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `integer` field. */
-  integer?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `language` field. */
-  language?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `point` field. */
-  point?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `propertyId` field. */
-  propertyId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `rect` field. */
-  rect?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `schedule` field. */
-  schedule?: InputMaybe<Scalars['JSON']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `text` field. */
-  text?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `time` field. */
-  time?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `timeUtc` field. */
-  timeUtc?: InputMaybe<Scalars['Time']['input']>;
-  /** Checks for equality with the object’s `unit` field. */
-  unit?: InputMaybe<Scalars['String']['input']>;
-  /** Checks for equality with the object’s `validFromKey` field. */
-  validFromKey?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `validToKey` field. */
-  validToKey?: InputMaybe<Scalars['BigInt']['input']>;
-};
-
-/** A filter to be used against `ValueVersion` object types. All fields are combined with a logical ‘and.’ */
-export type ValueVersionFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<ValueVersionFilter>>;
-  /** Filter by the object’s `boolean` field. */
-  boolean?: InputMaybe<BooleanFilter>;
-  /** Filter by the object’s `contextEdgeTypeId` field. */
-  contextEdgeTypeId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `contextLastToEntityId` field. */
-  contextLastToEntityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `contextRootId` field. */
-  contextRootId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `date` field. */
-  date?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `datetime` field. */
-  datetime?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `datetimeUtc` field. */
-  datetimeUtc?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `decimal` field. */
-  decimal?: InputMaybe<BigFloatFilter>;
-  /** Filter by the object’s `embedding` field. */
-  embedding?: InputMaybe<JsonFilter>;
-  /** Filter by the object’s `entityId` field. */
-  entityId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `float` field. */
-  float?: InputMaybe<FloatFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `integer` field. */
-  integer?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `language` field. */
-  language?: InputMaybe<StringFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<ValueVersionFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<ValueVersionFilter>>;
-  /** Filter by the object’s `point` field. */
-  point?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `propertyId` field. */
-  propertyId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `rect` field. */
-  rect?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `schedule` field. */
-  schedule?: InputMaybe<JsonFilter>;
+  space?: SpaceFilter | null | undefined;
   /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
+  spaceId?: UuidFilter | null | undefined;
   /** Filter by the object’s `text` field. */
-  text?: InputMaybe<StringFilter>;
+  text?: StringFilter | null | undefined;
   /** Filter by the object’s `time` field. */
-  time?: InputMaybe<StringFilter>;
+  time?: StringFilter | null | undefined;
   /** Filter by the object’s `timeUtc` field. */
-  timeUtc?: InputMaybe<TimeFilter>;
+  timeUtc?: TimeFilter | null | undefined;
   /** Filter by the object’s `unit` field. */
-  unit?: InputMaybe<StringFilter>;
-  /** Filter by the object’s `validFromKey` field. */
-  validFromKey?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `validToKey` field. */
-  validToKey?: InputMaybe<BigIntFilter>;
-};
-
-/** A connection to a list of `ValueVersion` values. */
-export type ValueVersionsConnection = {
-  __typename?: 'ValueVersionsConnection';
-  /** A list of edges which contains the `ValueVersion` and cursor to aid in pagination. */
-  edges: Array<ValueVersionsEdge>;
-  /** A list of `ValueVersion` objects. */
-  nodes: Array<ValueVersion>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `ValueVersion` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `ValueVersion` edge in the connection. */
-export type ValueVersionsEdge = {
-  __typename?: 'ValueVersionsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `ValueVersion` at the end of the edge. */
-  node: ValueVersion;
-};
-
-/** Methods to use when ordering `ValueVersion`. */
-export enum ValueVersionsOrderBy {
-  BooleanAsc = 'BOOLEAN_ASC',
-  BooleanDesc = 'BOOLEAN_DESC',
-  BytesAsc = 'BYTES_ASC',
-  BytesDesc = 'BYTES_DESC',
-  ContextEdgeTypeIdAsc = 'CONTEXT_EDGE_TYPE_ID_ASC',
-  ContextEdgeTypeIdDesc = 'CONTEXT_EDGE_TYPE_ID_DESC',
-  ContextLastToEntityIdAsc = 'CONTEXT_LAST_TO_ENTITY_ID_ASC',
-  ContextLastToEntityIdDesc = 'CONTEXT_LAST_TO_ENTITY_ID_DESC',
-  ContextRootIdAsc = 'CONTEXT_ROOT_ID_ASC',
-  ContextRootIdDesc = 'CONTEXT_ROOT_ID_DESC',
-  DatetimeAsc = 'DATETIME_ASC',
-  DatetimeDesc = 'DATETIME_DESC',
-  DatetimeUtcAsc = 'DATETIME_UTC_ASC',
-  DatetimeUtcDesc = 'DATETIME_UTC_DESC',
-  DateAsc = 'DATE_ASC',
-  DateDesc = 'DATE_DESC',
-  DecimalAsc = 'DECIMAL_ASC',
-  DecimalDesc = 'DECIMAL_DESC',
-  EmbeddingAsc = 'EMBEDDING_ASC',
-  EmbeddingDesc = 'EMBEDDING_DESC',
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  FloatAsc = 'FLOAT_ASC',
-  FloatDesc = 'FLOAT_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  IntegerAsc = 'INTEGER_ASC',
-  IntegerDesc = 'INTEGER_DESC',
-  LanguageAsc = 'LANGUAGE_ASC',
-  LanguageDesc = 'LANGUAGE_DESC',
-  Natural = 'NATURAL',
-  PointAsc = 'POINT_ASC',
-  PointDesc = 'POINT_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  PropertyIdAsc = 'PROPERTY_ID_ASC',
-  PropertyIdDesc = 'PROPERTY_ID_DESC',
-  RectAsc = 'RECT_ASC',
-  RectDesc = 'RECT_DESC',
-  ScheduleAsc = 'SCHEDULE_ASC',
-  ScheduleDesc = 'SCHEDULE_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  TextAsc = 'TEXT_ASC',
-  TextDesc = 'TEXT_DESC',
-  TimeAsc = 'TIME_ASC',
-  TimeDesc = 'TIME_DESC',
-  TimeUtcAsc = 'TIME_UTC_ASC',
-  TimeUtcDesc = 'TIME_UTC_DESC',
-  UnitAsc = 'UNIT_ASC',
-  UnitDesc = 'UNIT_DESC',
-  ValidFromKeyAsc = 'VALID_FROM_KEY_ASC',
-  ValidFromKeyDesc = 'VALID_FROM_KEY_DESC',
-  ValidToKeyAsc = 'VALID_TO_KEY_ASC',
-  ValidToKeyDesc = 'VALID_TO_KEY_DESC'
-}
-
-/** A connection to a list of `Value` values. */
-export type ValuesConnection = {
-  __typename?: 'ValuesConnection';
-  /** A list of edges which contains the `Value` and cursor to aid in pagination. */
-  edges: Array<ValuesEdge>;
-  /** A list of `Value` objects. */
-  nodes: Array<Value>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Value` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `Value` edge in the connection. */
-export type ValuesEdge = {
-  __typename?: 'ValuesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Value` at the end of the edge. */
-  node: Value;
-};
-
-/** Methods to use when ordering `Value`. */
-export enum ValuesOrderBy {
-  BooleanAsc = 'BOOLEAN_ASC',
-  BooleanDesc = 'BOOLEAN_DESC',
-  BytesAsc = 'BYTES_ASC',
-  BytesDesc = 'BYTES_DESC',
-  DatetimeAsc = 'DATETIME_ASC',
-  DatetimeDesc = 'DATETIME_DESC',
-  DatetimeUtcAsc = 'DATETIME_UTC_ASC',
-  DatetimeUtcDesc = 'DATETIME_UTC_DESC',
-  DateAsc = 'DATE_ASC',
-  DateDesc = 'DATE_DESC',
-  DecimalAsc = 'DECIMAL_ASC',
-  DecimalDesc = 'DECIMAL_DESC',
-  EmbeddingAsc = 'EMBEDDING_ASC',
-  EmbeddingDesc = 'EMBEDDING_DESC',
-  EntityIdAsc = 'ENTITY_ID_ASC',
-  EntityIdDesc = 'ENTITY_ID_DESC',
-  FloatAsc = 'FLOAT_ASC',
-  FloatDesc = 'FLOAT_DESC',
-  GlobalScoreAsc = 'GLOBAL_SCORE_ASC',
-  GlobalScoreDesc = 'GLOBAL_SCORE_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  IntegerAsc = 'INTEGER_ASC',
-  IntegerDesc = 'INTEGER_DESC',
-  LanguageAsc = 'LANGUAGE_ASC',
-  LanguageDesc = 'LANGUAGE_DESC',
-  LocalScoreAsc = 'LOCAL_SCORE_ASC',
-  LocalScoreDesc = 'LOCAL_SCORE_DESC',
-  Natural = 'NATURAL',
-  PointAsc = 'POINT_ASC',
-  PointDesc = 'POINT_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  PropertyIdAsc = 'PROPERTY_ID_ASC',
-  PropertyIdDesc = 'PROPERTY_ID_DESC',
-  RawScoreAsc = 'RAW_SCORE_ASC',
-  RawScoreDesc = 'RAW_SCORE_DESC',
-  RectAsc = 'RECT_ASC',
-  RectDesc = 'RECT_DESC',
-  ScheduleAsc = 'SCHEDULE_ASC',
-  ScheduleDesc = 'SCHEDULE_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  TextAsc = 'TEXT_ASC',
-  TextDesc = 'TEXT_DESC',
-  TimeAsc = 'TIME_ASC',
-  TimeDesc = 'TIME_DESC',
-  TimeUtcAsc = 'TIME_UTC_ASC',
-  TimeUtcDesc = 'TIME_UTC_DESC',
-  UnitAsc = 'UNIT_ASC',
-  UnitDesc = 'UNIT_DESC'
-}
-
-export type Vote = Node & {
-  __typename?: 'Vote';
-  blockNumber: Scalars['BigInt']['output'];
-  blockTimestamp: Scalars['Datetime']['output'];
-  createdAt: Scalars['Datetime']['output'];
-  id: Scalars['Int']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  objectId: Scalars['UUID']['output'];
-  objectType: Scalars['Int']['output'];
-  spaceId: Scalars['UUID']['output'];
-  vote: Scalars['Int']['output'];
-  voterId: Scalars['UUID']['output'];
-};
-
-/** A condition to be used against `Vote` object types. All fields are tested for equality and combined with a logical ‘and.’ */
-export type VoteCondition = {
-  /** Checks for equality with the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `blockTimestamp` field. */
-  blockTimestamp?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `createdAt` field. */
-  createdAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `objectId` field. */
-  objectId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `objectType` field. */
-  objectType?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `vote` field. */
-  vote?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `voterId` field. */
-  voterId?: InputMaybe<Scalars['UUID']['input']>;
-};
-
-/** A filter to be used against `Vote` object types. All fields are combined with a logical ‘and.’ */
-export type VoteFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<VoteFilter>>;
-  /** Filter by the object’s `blockNumber` field. */
-  blockNumber?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `blockTimestamp` field. */
-  blockTimestamp?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `createdAt` field. */
-  createdAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<IntFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<VoteFilter>;
-  /** Filter by the object’s `objectId` field. */
-  objectId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `objectType` field. */
-  objectType?: InputMaybe<IntFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<VoteFilter>>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `vote` field. */
-  vote?: InputMaybe<IntFilter>;
-  /** Filter by the object’s `voterId` field. */
-  voterId?: InputMaybe<UuidFilter>;
+  unit?: StringFilter | null | undefined;
 };
 
 export enum VoteOption {
@@ -6536,177 +1191,29 @@ export enum VoteOption {
 /** A filter to be used against VoteOption fields. All fields are combined with a logical ‘and.’ */
 export type VoteOptionFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<VoteOption>;
+  distinctFrom?: VoteOption | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<VoteOption>;
+  greaterThan?: VoteOption | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<VoteOption>;
+  greaterThanOrEqualTo?: VoteOption | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<VoteOption>>;
+  in?: Array<VoteOption> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<VoteOption>;
+  is?: VoteOption | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<VoteOption>;
+  isNot?: VoteOption | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<VoteOption>;
+  lessThan?: VoteOption | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<VoteOption>;
+  lessThanOrEqualTo?: VoteOption | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<VoteOption>;
+  notDistinctFrom?: VoteOption | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<VoteOption>>;
-};
-
-/** A connection to a list of `Vote` values. */
-export type VotesConnection = {
-  __typename?: 'VotesConnection';
-  /** A list of edges which contains the `Vote` and cursor to aid in pagination. */
-  edges: Array<VotesEdge>;
-  /** A list of `Vote` objects. */
-  nodes: Array<Vote>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `Vote` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-export type VotesCount = Node & {
-  __typename?: 'VotesCount';
-  downvotes: Scalars['BigInt']['output'];
-  id: Scalars['Int']['output'];
-  /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
-  nodeId: Scalars['ID']['output'];
-  objectId: Scalars['UUID']['output'];
-  objectType: Scalars['Int']['output'];
-  spaceId: Scalars['UUID']['output'];
-  updatedAt: Scalars['Datetime']['output'];
-  upvotes: Scalars['BigInt']['output'];
-};
-
-/**
- * A condition to be used against `VotesCount` object types. All fields are tested
- * for equality and combined with a logical ‘and.’
- */
-export type VotesCountCondition = {
-  /** Checks for equality with the object’s `downvotes` field. */
-  downvotes?: InputMaybe<Scalars['BigInt']['input']>;
-  /** Checks for equality with the object’s `id` field. */
-  id?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `objectId` field. */
-  objectId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `objectType` field. */
-  objectType?: InputMaybe<Scalars['Int']['input']>;
-  /** Checks for equality with the object’s `spaceId` field. */
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  /** Checks for equality with the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<Scalars['Datetime']['input']>;
-  /** Checks for equality with the object’s `upvotes` field. */
-  upvotes?: InputMaybe<Scalars['BigInt']['input']>;
-};
-
-/** A filter to be used against `VotesCount` object types. All fields are combined with a logical ‘and.’ */
-export type VotesCountFilter = {
-  /** Checks for all expressions in this list. */
-  and?: InputMaybe<Array<VotesCountFilter>>;
-  /** Filter by the object’s `downvotes` field. */
-  downvotes?: InputMaybe<BigIntFilter>;
-  /** Filter by the object’s `id` field. */
-  id?: InputMaybe<IntFilter>;
-  /** Negates the expression. */
-  not?: InputMaybe<VotesCountFilter>;
-  /** Filter by the object’s `objectId` field. */
-  objectId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `objectType` field. */
-  objectType?: InputMaybe<IntFilter>;
-  /** Checks for any expressions in this list. */
-  or?: InputMaybe<Array<VotesCountFilter>>;
-  /** Filter by the object’s `spaceId` field. */
-  spaceId?: InputMaybe<UuidFilter>;
-  /** Filter by the object’s `updatedAt` field. */
-  updatedAt?: InputMaybe<DatetimeFilter>;
-  /** Filter by the object’s `upvotes` field. */
-  upvotes?: InputMaybe<BigIntFilter>;
-};
-
-/** A connection to a list of `VotesCount` values. */
-export type VotesCountsConnection = {
-  __typename?: 'VotesCountsConnection';
-  /** A list of edges which contains the `VotesCount` and cursor to aid in pagination. */
-  edges: Array<VotesCountsEdge>;
-  /** A list of `VotesCount` objects. */
-  nodes: Array<VotesCount>;
-  /** Information to aid in pagination. */
-  pageInfo: PageInfo;
-  /** The count of *all* `VotesCount` you could get from the connection. */
-  totalCount: Scalars['Int']['output'];
-};
-
-/** A `VotesCount` edge in the connection. */
-export type VotesCountsEdge = {
-  __typename?: 'VotesCountsEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `VotesCount` at the end of the edge. */
-  node: VotesCount;
-};
-
-/** Methods to use when ordering `VotesCount`. */
-export enum VotesCountsOrderBy {
-  DownvotesAsc = 'DOWNVOTES_ASC',
-  DownvotesDesc = 'DOWNVOTES_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  ObjectIdAsc = 'OBJECT_ID_ASC',
-  ObjectIdDesc = 'OBJECT_ID_DESC',
-  ObjectTypeAsc = 'OBJECT_TYPE_ASC',
-  ObjectTypeDesc = 'OBJECT_TYPE_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  UpdatedAtAsc = 'UPDATED_AT_ASC',
-  UpdatedAtDesc = 'UPDATED_AT_DESC',
-  UpvotesAsc = 'UPVOTES_ASC',
-  UpvotesDesc = 'UPVOTES_DESC'
-}
-
-/** A `Vote` edge in the connection. */
-export type VotesEdge = {
-  __typename?: 'VotesEdge';
-  /** A cursor for use in pagination. */
-  cursor?: Maybe<Scalars['Cursor']['output']>;
-  /** The `Vote` at the end of the edge. */
-  node: Vote;
+  notIn?: Array<VoteOption> | null | undefined;
 };
 
-/** Methods to use when ordering `Vote`. */
-export enum VotesOrderBy {
-  BlockNumberAsc = 'BLOCK_NUMBER_ASC',
-  BlockNumberDesc = 'BLOCK_NUMBER_DESC',
-  BlockTimestampAsc = 'BLOCK_TIMESTAMP_ASC',
-  BlockTimestampDesc = 'BLOCK_TIMESTAMP_DESC',
-  CreatedAtAsc = 'CREATED_AT_ASC',
-  CreatedAtDesc = 'CREATED_AT_DESC',
-  IdAsc = 'ID_ASC',
-  IdDesc = 'ID_DESC',
-  Natural = 'NATURAL',
-  ObjectIdAsc = 'OBJECT_ID_ASC',
-  ObjectIdDesc = 'OBJECT_ID_DESC',
-  ObjectTypeAsc = 'OBJECT_TYPE_ASC',
-  ObjectTypeDesc = 'OBJECT_TYPE_DESC',
-  PrimaryKeyAsc = 'PRIMARY_KEY_ASC',
-  PrimaryKeyDesc = 'PRIMARY_KEY_DESC',
-  SpaceIdAsc = 'SPACE_ID_ASC',
-  SpaceIdDesc = 'SPACE_ID_DESC',
-  VoterIdAsc = 'VOTER_ID_ASC',
-  VoterIdDesc = 'VOTER_ID_DESC',
-  VoteAsc = 'VOTE_ASC',
-  VoteDesc = 'VOTE_DESC'
-}
-
 export enum VotingMode {
   Fast = 'FAST',
   Slow = 'SLOW'
@@ -6715,409 +1222,344 @@ export enum VotingMode {
 /** A filter to be used against VotingMode fields. All fields are combined with a logical ‘and.’ */
 export type VotingModeFilter = {
   /** Not equal to the specified value, treating null like an ordinary value. */
-  distinctFrom?: InputMaybe<VotingMode>;
+  distinctFrom?: VotingMode | null | undefined;
   /** Greater than the specified value. */
-  greaterThan?: InputMaybe<VotingMode>;
+  greaterThan?: VotingMode | null | undefined;
   /** Greater than or equal to the specified value. */
-  greaterThanOrEqualTo?: InputMaybe<VotingMode>;
+  greaterThanOrEqualTo?: VotingMode | null | undefined;
   /** Included in the specified list. */
-  in?: InputMaybe<Array<VotingMode>>;
+  in?: Array<VotingMode> | null | undefined;
   /** Equal to the specified value. */
-  is?: InputMaybe<VotingMode>;
+  is?: VotingMode | null | undefined;
   /** Not equal to the specified value. */
-  isNot?: InputMaybe<VotingMode>;
+  isNot?: VotingMode | null | undefined;
   /** Is null (if `true` is specified) or is not null (if `false` is specified). */
-  isNull?: InputMaybe<Scalars['Boolean']['input']>;
+  isNull?: boolean | null | undefined;
   /** Less than the specified value. */
-  lessThan?: InputMaybe<VotingMode>;
+  lessThan?: VotingMode | null | undefined;
   /** Less than or equal to the specified value. */
-  lessThanOrEqualTo?: InputMaybe<VotingMode>;
+  lessThanOrEqualTo?: VotingMode | null | undefined;
   /** Equal to the specified value, treating null like an ordinary value. */
-  notDistinctFrom?: InputMaybe<VotingMode>;
+  notDistinctFrom?: VotingMode | null | undefined;
   /** Not included in the specified list. */
-  notIn?: InputMaybe<Array<VotingMode>>;
+  notIn?: Array<VotingMode> | null | undefined;
 };
 
-export type RelationToEntityFragment = { __typename?: 'Entity', id: any, name?: string | null, types?: Array<{ __typename?: 'Entity', id: any }> | null, valuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any, text?: string | null }> } & { ' $fragmentName'?: 'RelationToEntityFragment' };
+export type RelationToEntityFragment = { id: any, name: string | null, types: Array<{ id: any }> | null, valuesList: Array<{ spaceId: any, propertyId: any, text: string | null }> } & { ' $fragmentName'?: 'RelationToEntityFragment' };
 
-export type EntityValueFieldsFragment = { __typename?: 'Value', spaceId: any, text?: string | null, integer?: any | null, float?: number | null, point?: any | null, boolean?: boolean | null, time?: any | null, language?: any | null, unit?: string | null, datetime?: any | null, date?: any | null, decimal?: any | null, schedule?: any | null, property?: (
-    { __typename?: 'PropertyInfo' }
-    & { ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } }
-  ) | null } & { ' $fragmentName'?: 'EntityValueFieldsFragment' };
+export type EntityValueFieldsFragment = { spaceId: any, text: string | null, integer: any, float: number | null, point: any, boolean: boolean | null, time: any, language: any, unit: string | null, datetime: any, date: any, decimal: any, schedule: any, property: { ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } } | null } & { ' $fragmentName'?: 'EntityValueFieldsFragment' };
 
-export type RelationFieldsFragment = { __typename?: 'Relation', id: any, spaceId: any, position?: string | null, verified?: boolean | null, entityId: any, toSpaceId?: any | null, fromEntity?: { __typename?: 'Entity', id: any, name?: string | null } | null, toEntity?: (
-    { __typename?: 'Entity' }
-    & { ' $fragmentRefs'?: { 'RelationToEntityFragment': RelationToEntityFragment } }
-  ) | null, type?: { __typename?: 'PropertyInfo', id?: any | null, name?: string | null } | null } & { ' $fragmentName'?: 'RelationFieldsFragment' };
+export type RelationFieldsFragment = { id: any, spaceId: any, position: string | null, verified: boolean | null, entityId: any, toSpaceId: any, fromEntity: { id: any, name: string | null } | null, toEntity: { ' $fragmentRefs'?: { 'RelationToEntityFragment': RelationToEntityFragment } } | null, type: { id: any, name: string | null } | null } & { ' $fragmentName'?: 'RelationFieldsFragment' };
 
-export type FullEntityFragment = { __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, createdAt: string, createdAtBlock: string, updatedAt: string, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, valuesList: Array<(
-    { __typename?: 'Value' }
-    & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-  )>, relationsList: Array<(
-    { __typename?: 'Relation' }
-    & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-  )> } & { ' $fragmentName'?: 'FullEntityFragment' };
+export type FullEntityFragment = { id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, createdAt: string, createdAtBlock: string, updatedAt: string, types: Array<{ id: any, name: string | null }> | null, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relationsList: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> } & { ' $fragmentName'?: 'FullEntityFragment' };
 
 export type AllEntitiesQueryVariables = Exact<{
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  spaceIds?: InputMaybe<UuidFilter>;
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  typeIds?: InputMaybe<UuidFilter>;
-  limit?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  filter?: InputMaybe<EntityFilter>;
-  orderBy?: InputMaybe<Array<EntitiesOrderBy> | EntitiesOrderBy>;
+  spaceId?: any;
+  spaceIds?: UuidFilter | null | undefined;
+  typeId?: any;
+  typeIds?: UuidFilter | null | undefined;
+  limit?: number | null | undefined;
+  offset?: number | null | undefined;
+  filter?: EntityFilter | null | undefined;
+  orderBy?: Array<EntitiesOrderBy> | EntitiesOrderBy | null | undefined;
 }>;
 
 
-export type AllEntitiesQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, updatedAt: string, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, allValuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any }>, allRelationsList: Array<{ __typename?: 'Relation', spaceId: any }>, valuesList: Array<(
-      { __typename?: 'Value' }
-      & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-    )>, relationsList: Array<(
-      { __typename?: 'Relation' }
-      & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-    )> }> | null };
+export type AllEntitiesQuery = { entities: Array<{ id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, updatedAt: string, types: Array<{ id: any, name: string | null }> | null, allValuesList: Array<{ spaceId: any, propertyId: any }>, allRelationsList: Array<{ spaceId: any }>, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relationsList: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> }> | null };
 
 export type EntitiesBatchQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  filter?: EntityFilter | null | undefined;
+  spaceId?: any;
 }>;
 
 
-export type EntitiesBatchQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, valuesList: Array<(
-      { __typename?: 'Value' }
-      & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-    )>, relationsList: Array<(
-      { __typename?: 'Relation' }
-      & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-    )> }> | null };
+export type EntitiesBatchQuery = { entities: Array<{ id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relationsList: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> }> | null };
 
 export type EntitySpacesBatchQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
+  filter?: EntityFilter | null | undefined;
 }>;
 
 
-export type EntitySpacesBatchQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, spaceIds?: Array<any | null> | null, allValuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any }>, allRelationsList: Array<{ __typename?: 'Relation', spaceId: any }> }> | null };
+export type EntitySpacesBatchQuery = { entities: Array<{ id: any, spaceIds: Array<any> | null, allValuesList: Array<{ spaceId: any, propertyId: any }>, allRelationsList: Array<{ spaceId: any }> }> | null };
 
 export type EntityQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  cursor?: InputMaybe<Scalars['Cursor']['input']>;
+  id: any;
+  spaceId?: any;
+  cursor?: any;
 }>;
 
 
-export type EntityQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, updatedAt: string, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, allValuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any }>, allRelationsList: Array<{ __typename?: 'Relation', spaceId: any }>, valuesList: Array<(
-      { __typename?: 'Value' }
-      & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-    )>, relations: { __typename?: 'RelationsConnection', pageInfo: { __typename?: 'PageInfo', hasNextPage: boolean, endCursor?: any | null }, nodes: Array<(
-        { __typename?: 'Relation' }
-        & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-      )> } } | null };
+export type EntityQuery = { entity: { id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, updatedAt: string, types: Array<{ id: any, name: string | null }> | null, allValuesList: Array<{ spaceId: any, propertyId: any }>, allRelationsList: Array<{ spaceId: any }>, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relations: { pageInfo: { hasNextPage: boolean, endCursor: any }, nodes: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> } } | null };
 
 export type EntityRelationsPageQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  cursor?: InputMaybe<Scalars['Cursor']['input']>;
+  id: any;
+  spaceId?: any;
+  cursor?: any;
 }>;
 
 
-export type EntityRelationsPageQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', relations: { __typename?: 'RelationsConnection', pageInfo: { __typename?: 'PageInfo', hasNextPage: boolean, endCursor?: any | null }, nodes: Array<(
-        { __typename?: 'Relation' }
-        & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-      )> } } | null };
+export type EntityRelationsPageQuery = { entity: { relations: { pageInfo: { hasNextPage: boolean, endCursor: any }, nodes: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> } } | null };
 
 export type FullRelationFragment = (
-  { __typename?: 'Relation', entity?: { __typename?: 'Entity', id: any, name?: string | null } | null }
+  { entity: { id: any, name: string | null } | null }
   & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
 ) & { ' $fragmentName'?: 'FullRelationFragment' };
 
 export type RelationEntityRelationsQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  id: any;
+  spaceId?: any;
 }>;
 
 
-export type RelationEntityRelationsQuery = { __typename?: 'Query', relations?: Array<(
-    { __typename?: 'Relation' }
-    & { ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }
-  )> | null };
+export type RelationEntityRelationsQuery = { relations: Array<{ ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }> | null };
 
 export type RelationsByToEntityIdsQueryVariables = Exact<{
-  toEntityIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];
-  typeId?: InputMaybe<Scalars['UUID']['input']>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  toEntityIds: Array<any> | any;
+  typeId?: any;
+  spaceId?: any;
 }>;
 
 
-export type RelationsByToEntityIdsQuery = { __typename?: 'Query', relations?: Array<{ __typename?: 'Relation', id: any, toEntityId: any, spaceId: any, fromEntityId: any }> | null };
+export type RelationsByToEntityIdsQuery = { relations: Array<{ id: any, toEntityId: any, spaceId: any, fromEntityId: any }> | null };
 
 export type RelationsByFromEntityIdQueryVariables = Exact<{
-  fromEntityId: Scalars['UUID']['input'];
-  typeId: Scalars['UUID']['input'];
-  spaceId: Scalars['UUID']['input'];
+  fromEntityId: any;
+  typeId: any;
+  spaceId: any;
 }>;
 
 
-export type RelationsByFromEntityIdQuery = { __typename?: 'Query', relations?: Array<(
-    { __typename?: 'Relation' }
-    & { ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }
-  )> | null };
+export type RelationsByFromEntityIdQuery = { relations: Array<{ ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }> | null };
 
 export type EntityPageQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  id: any;
+  spaceId?: any;
 }>;
 
 
-export type EntityPageQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, allValuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any }>, allRelationsList: Array<{ __typename?: 'Relation', spaceId: any }>, valuesList: Array<(
-      { __typename?: 'Value' }
-      & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-    )>, relationsList: Array<(
-      { __typename?: 'Relation' }
-      & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-    )> } | null, relations?: Array<(
-    { __typename?: 'Relation' }
-    & { ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }
-  )> | null };
+export type EntityPageQuery = { entity: { id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null, allValuesList: Array<{ spaceId: any, propertyId: any }>, allRelationsList: Array<{ spaceId: any }>, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relationsList: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> } | null, relations: Array<{ ' $fragmentRefs'?: { 'FullRelationFragment': FullRelationFragment } }> | null };
 
 export type EntityTypesQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  id: any;
+  spaceId?: any;
 }>;
 
 
-export type EntityTypesQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null } | null };
+export type EntityTypesQuery = { entity: { types: Array<{ id: any, name: string | null }> | null } | null };
 
 export type EntityExistsQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
+  id: any;
 }>;
 
 
-export type EntityExistsQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', id: any } | null };
+export type EntityExistsQuery = { entity: { id: any } | null };
 
 export type EntityCommentReplyBacklinksPageQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  replyToTypeId: Scalars['UUID']['input'];
-  commentTypeId: Scalars['UUID']['input'];
-  first: Scalars['Int']['input'];
-  offset: Scalars['Int']['input'];
+  id: any;
+  replyToTypeId: any;
+  commentTypeId: any;
+  first: number;
+  offset: number;
 }>;
 
 
-export type EntityCommentReplyBacklinksPageQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', backlinksList: Array<{ __typename?: 'Relation', fromEntity?: { __typename?: 'Entity', id: any } | null }> } | null };
+export type EntityCommentReplyBacklinksPageQuery = { entity: { backlinksList: Array<{ fromEntity: { id: any } | null }> } | null };
 
 export type EntitiesBatchForCommentsQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
+  filter?: EntityFilter | null | undefined;
 }>;
 
 
-export type EntitiesBatchForCommentsQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, createdAt: string, updatedAt: string, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, valuesList: Array<(
-      { __typename?: 'Value' }
-      & { ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }
-    )>, relationsList: Array<(
-      { __typename?: 'Relation' }
-      & { ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }
-    )> }> | null };
+export type EntitiesBatchForCommentsQuery = { entities: Array<{ id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, createdAt: string, updatedAt: string, types: Array<{ id: any, name: string | null }> | null, valuesList: Array<{ ' $fragmentRefs'?: { 'EntityValueFieldsFragment': EntityValueFieldsFragment } }>, relationsList: Array<{ ' $fragmentRefs'?: { 'RelationFieldsFragment': RelationFieldsFragment } }> }> | null };
 
 export type EntityBacklinksPageQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  id: any;
+  spaceId?: any;
 }>;
 
 
-export type EntityBacklinksPageQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', backlinksList: Array<{ __typename?: 'Relation', spaceId: any, fromEntity?: { __typename?: 'Entity', id: any, name?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null, spaceIds?: Array<any | null> | null }> | null } | null }> } | null };
+export type EntityBacklinksPageQuery = { entity: { backlinksList: Array<{ spaceId: any, fromEntity: { id: any, name: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null, spaceIds: Array<any> | null }> | null } | null }> } | null };
 
-export type FullSpaceFragment = { __typename?: 'Space', id: any, type: SpaceTypes, address: string, topicId?: any | null, topic?: (
-    { __typename?: 'Entity' }
-    & { ' $fragmentRefs'?: { 'FullEntityFragment': FullEntityFragment } }
-  ) | null, members: { __typename?: 'MembersConnection', totalCount: number }, membersList: Array<{ __typename?: 'Member', memberSpaceId: any }>, editors: { __typename?: 'EditorsConnection', totalCount: number }, editorsList: Array<{ __typename?: 'Editor', memberSpaceId: any }>, spaceVotingSetting?: { __typename?: 'SpaceVotingSetting', flatSupportThreshold: any } | null, page?: (
-    { __typename?: 'Entity' }
-    & { ' $fragmentRefs'?: { 'FullEntityFragment': FullEntityFragment } }
-  ) | null } & { ' $fragmentName'?: 'FullSpaceFragment' };
+export type FullSpaceFragment = { id: any, type: SpaceTypes, address: string, topicId: any, topic: { ' $fragmentRefs'?: { 'FullEntityFragment': FullEntityFragment } } | null, members: { totalCount: number }, membersList: Array<{ memberSpaceId: any }>, editors: { totalCount: number }, editorsList: Array<{ memberSpaceId: any }>, spaceVotingSetting: { flatSupportThreshold: any } | null, page: { ' $fragmentRefs'?: { 'FullEntityFragment': FullEntityFragment } } | null } & { ' $fragmentName'?: 'FullSpaceFragment' };
 
 export type SpaceQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
+  id: any;
 }>;
 
 
-export type SpaceQuery = { __typename?: 'Query', space?: (
-    { __typename?: 'Space' }
-    & { ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } }
-  ) | null };
+export type SpaceQuery = { space: { ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } } | null };
 
 export type SpacesQueryVariables = Exact<{
-  filter?: InputMaybe<SpaceFilter>;
-  limit?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
+  filter?: SpaceFilter | null | undefined;
+  limit?: number | null | undefined;
+  offset?: number | null | undefined;
 }>;
 
 
-export type SpacesQuery = { __typename?: 'Query', spaces?: Array<(
-    { __typename?: 'Space' }
-    & { ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } }
-  )> | null };
+export type SpacesQuery = { spaces: Array<{ ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } }> | null };
 
 export type SpacesWhereMemberQueryVariables = Exact<{
-  memberSpaceId: Scalars['UUID']['input'];
+  memberSpaceId: any;
 }>;
 
 
-export type SpacesWhereMemberQuery = { __typename?: 'Query', spaces?: Array<(
-    { __typename?: 'Space' }
-    & { ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } }
-  )> | null };
+export type SpacesWhereMemberQuery = { spaces: Array<{ ' $fragmentRefs'?: { 'FullSpaceFragment': FullSpaceFragment } }> | null };
 
 export type IsMemberOfSpaceQueryVariables = Exact<{
-  spaceId: Scalars['UUID']['input'];
-  memberSpaceId: Scalars['UUID']['input'];
+  spaceId: any;
+  memberSpaceId: any;
 }>;
 
 
-export type IsMemberOfSpaceQuery = { __typename?: 'Query', space?: { __typename?: 'Space', membersList: Array<{ __typename?: 'Member', memberSpaceId: any }> } | null };
+export type IsMemberOfSpaceQuery = { space: { membersList: Array<{ memberSpaceId: any }> } | null };
 
 export type IsEditorOfSpaceQueryVariables = Exact<{
-  spaceId: Scalars['UUID']['input'];
-  memberSpaceId: Scalars['UUID']['input'];
+  spaceId: any;
+  memberSpaceId: any;
 }>;
 
 
-export type IsEditorOfSpaceQuery = { __typename?: 'Query', space?: { __typename?: 'Space', editorsList: Array<{ __typename?: 'Editor', memberSpaceId: any }> } | null };
+export type IsEditorOfSpaceQuery = { space: { editorsList: Array<{ memberSpaceId: any }> } | null };
 
 export type SpaceMembersPageQueryVariables = Exact<{
-  spaceId: Scalars['UUID']['input'];
-  first: Scalars['Int']['input'];
-  offset: Scalars['Int']['input'];
+  spaceId: any;
+  first: number;
+  offset: number;
 }>;
 
 
-export type SpaceMembersPageQuery = { __typename?: 'Query', space?: { __typename?: 'Space', members: { __typename?: 'MembersConnection', totalCount: number }, membersList: Array<{ __typename?: 'Member', memberSpaceId: any }> } | null };
+export type SpaceMembersPageQuery = { space: { members: { totalCount: number }, membersList: Array<{ memberSpaceId: any }> } | null };
 
 export type SpaceEditorsPageQueryVariables = Exact<{
-  spaceId: Scalars['UUID']['input'];
-  first: Scalars['Int']['input'];
-  offset: Scalars['Int']['input'];
+  spaceId: any;
+  first: number;
+  offset: number;
 }>;
 
 
-export type SpaceEditorsPageQuery = { __typename?: 'Query', space?: { __typename?: 'Space', editors: { __typename?: 'EditorsConnection', totalCount: number }, editorsList: Array<{ __typename?: 'Editor', memberSpaceId: any }> } | null };
+export type SpaceEditorsPageQuery = { space: { editors: { totalCount: number }, editorsList: Array<{ memberSpaceId: any }> } | null };
 
-export type PropertyFragmentFragment = { __typename?: 'PropertyInfo', id?: any | null, name?: string | null, dataTypeId?: any | null, dataTypeName?: string | null, renderableTypeId?: any | null, renderableTypeName?: string | null, format?: string | null, isType?: boolean | null } & { ' $fragmentName'?: 'PropertyFragmentFragment' };
+export type PropertyFragmentFragment = { id: any, name: string | null, dataTypeId: any, dataTypeName: string | null, renderableTypeId: any, renderableTypeName: string | null, format: string | null, isType: boolean | null } & { ' $fragmentName'?: 'PropertyFragmentFragment' };
 
 export type PropertyQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
+  id: any;
 }>;
 
 
-export type PropertyQuery = { __typename?: 'Query', property?: (
-    { __typename?: 'PropertyInfo' }
-    & { ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } }
-  ) | null };
+export type PropertyQuery = { property: { ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } } | null };
 
 export type PropertiesBatchQueryVariables = Exact<{
-  ids: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];
+  ids: Array<any> | any;
 }>;
 
 
-export type PropertiesBatchQuery = { __typename?: 'Query', properties?: Array<(
-    { __typename?: 'PropertyInfo' }
-    & { ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } }
-  )> | null };
+export type PropertiesBatchQuery = { properties: Array<{ ' $fragmentRefs'?: { 'PropertyFragmentFragment': PropertyFragmentFragment } }> | null };
 
 export type EntityNamesQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
+  filter?: EntityFilter | null | undefined;
 }>;
 
 
-export type EntityNamesQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null };
+export type EntityNamesQuery = { entities: Array<{ id: any, name: string | null }> | null };
 
 export type ResultQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
+  id: any;
 }>;
 
 
-export type ResultQuery = { __typename?: 'Query', entity?: { __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null } | null };
+export type ResultQuery = { entity: { id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null } | null };
 
 export type ResultsQueryVariables = Exact<{
-  query: Scalars['String']['input'];
-  filter?: InputMaybe<EntityFilter>;
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
-  limit?: InputMaybe<Scalars['Int']['input']>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
+  query: string;
+  filter?: EntityFilter | null | undefined;
+  spaceId?: any;
+  limit?: number | null | undefined;
+  offset?: number | null | undefined;
 }>;
 
 
-export type ResultsQuery = { __typename?: 'Query', search?: Array<{ __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null }> | null };
+export type ResultsQuery = { search: Array<{ id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null }> | null };
 
 export type EntitiesPageQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
-  first: Scalars['Int']['input'];
-  offset: Scalars['Int']['input'];
+  filter?: EntityFilter | null | undefined;
+  first: number;
+  offset: number;
 }>;
 
 
-export type EntitiesPageQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null }> | null };
+export type EntitiesPageQuery = { entities: Array<{ id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null }> | null };
 
 export type ImportNameValuesQueryVariables = Exact<{
-  propertyId: Scalars['UUID']['input'];
-  texts?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  entityFilter?: InputMaybe<EntityFilter>;
+  propertyId: any;
+  texts?: Array<string> | string | null | undefined;
+  first?: number | null | undefined;
+  entityFilter?: EntityFilter | null | undefined;
 }>;
 
 
-export type ImportNameValuesQuery = { __typename?: 'Query', values?: Array<{ __typename?: 'Value', id: string, text?: string | null, spaceId: any, entity?: { __typename?: 'Entity', id: any, name?: string | null, typeIds?: Array<any | null> | null, backlinks: { __typename?: 'RelationsConnection', totalCount: number }, relations: { __typename?: 'RelationsConnection', totalCount: number } } | null }> | null };
+export type ImportNameValuesQuery = { values: Array<{ id: string, text: string | null, spaceId: any, entity: { id: any, name: string | null, typeIds: Array<any> | null, backlinks: { totalCount: number }, relations: { totalCount: number } } | null }> | null };
 
 export type EntityTiebreakerBatchQueryVariables = Exact<{
-  filter?: InputMaybe<EntityFilter>;
+  filter?: EntityFilter | null | undefined;
 }>;
 
 
-export type EntityTiebreakerBatchQuery = { __typename?: 'Query', entities?: Array<{ __typename?: 'Entity', id: any, createdAt: string, backlinks: { __typename?: 'RelationsConnection', totalCount: number }, relations: { __typename?: 'RelationsConnection', totalCount: number }, values: { __typename?: 'ValuesConnection', totalCount: number } }> | null };
+export type EntityTiebreakerBatchQuery = { entities: Array<{ id: any, createdAt: string, backlinks: { totalCount: number }, relations: { totalCount: number }, values: { totalCount: number } }> | null };
 
 export type RelationEntityMinimalQueryVariables = Exact<{
-  id: Scalars['UUID']['input'];
-  spaceId?: InputMaybe<Scalars['UUID']['input']>;
+  id: any;
+  spaceId?: any;
+}>;
+
+
+export type RelationEntityMinimalQuery = { relation: { id: any, entity: { id: any, name: string | null, description: string | null, spaceIds: Array<any> | null, types: Array<{ id: any, name: string | null }> | null, allValuesList: Array<{ spaceId: any, propertyId: any }>, allRelationsList: Array<{ spaceId: any }>, valuesList: Array<{ spaceId: any, text: string | null, integer: any, float: number | null, point: any, boolean: boolean | null, time: any, language: any, unit: string | null, datetime: any, date: any, decimal: any, schedule: any, property: { id: any, name: string | null, dataTypeId: any, dataTypeName: string | null, renderableTypeId: any, renderableTypeName: string | null, format: string | null } | null }>, relationsList: Array<{ verified: boolean | null, toSpaceId: any, position: string | null, spaceId: any, id: any, entityId: any, fromEntity: { id: any, name: string | null } | null, toEntity: { ' $fragmentRefs'?: { 'RelationToEntityFragment': RelationToEntityFragment } } | null, type: { id: any, name: string | null, description: string | null } | null }> } | null } | null };
+
+export type EntityResponseCountsQueryVariables = Exact<{
+  objectId: any;
+  objectType: number;
+  spaceId: any;
+  voteKind: number;
 }>;
 
 
-export type RelationEntityMinimalQuery = { __typename?: 'Query', relation?: { __typename?: 'Relation', id: any, entity?: { __typename?: 'Entity', id: any, name?: string | null, description?: string | null, spaceIds?: Array<any | null> | null, types?: Array<{ __typename?: 'Entity', id: any, name?: string | null }> | null, allValuesList: Array<{ __typename?: 'Value', spaceId: any, propertyId: any }>, allRelationsList: Array<{ __typename?: 'Relation', spaceId: any }>, valuesList: Array<{ __typename?: 'Value', spaceId: any, text?: string | null, integer?: any | null, float?: number | null, point?: any | null, boolean?: boolean | null, time?: any | null, language?: any | null, unit?: string | null, datetime?: any | null, date?: any | null, decimal?: any | null, schedule?: any | null, property?: { __typename?: 'PropertyInfo', id?: any | null, name?: string | null, dataTypeId?: any | null, dataTypeName?: string | null, renderableTypeId?: any | null, renderableTypeName?: string | null, format?: string | null } | null }>, relationsList: Array<{ __typename?: 'Relation', verified?: boolean | null, toSpaceId?: any | null, position?: string | null, spaceId: any, id: any, entityId: any, fromEntity?: { __typename?: 'Entity', id: any, name?: string | null } | null, toEntity?: (
-          { __typename?: 'Entity' }
-          & { ' $fragmentRefs'?: { 'RelationToEntityFragment': RelationToEntityFragment } }
-        ) | null, type?: { __typename?: 'PropertyInfo', id?: any | null, name?: string | null, description?: string | null } | null }> } | null } | null };
+export type EntityResponseCountsQuery = { votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind: { positive: any, negative: any, voteKind: number } | null };
 
-export type EntityVoteCountQueryVariables = Exact<{
-  objectId: Scalars['UUID']['input'];
-  objectType: Scalars['Int']['input'];
+export type UserEntityResponseQueryVariables = Exact<{
+  userId: any;
+  objectId: any;
+  objectType: number;
+  spaceId: any;
+  voteKind: number;
 }>;
 
 
-export type EntityVoteCountQuery = { __typename?: 'Query', votesCountsConnection?: { __typename?: 'VotesCountsConnection', nodes: Array<{ __typename?: 'VotesCount', spaceId: any, upvotes: any, downvotes: any }> } | null };
+export type UserEntityResponseQuery = { userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind: { voteType: number } | null };
 
-export type UserEntityVoteQueryVariables = Exact<{
-  userId: Scalars['UUID']['input'];
-  objectId: Scalars['UUID']['input'];
-  objectType: Scalars['Int']['input'];
-  spaceId: Scalars['UUID']['input'];
+export type EntityRespondersQueryVariables = Exact<{
+  objectId: any;
+  objectType: number;
+  spaceId: any;
+  voteKind: number;
 }>;
 
 
-export type UserEntityVoteQuery = { __typename?: 'Query', userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId?: { __typename?: 'UserVote', voteType: number } | null };
+export type EntityRespondersQuery = { userVotes: Array<{ userId: any, voteType: number }> | null };
 
-export type EntityVotersQueryVariables = Exact<{
-  objectId: Scalars['UUID']['input'];
-  objectType: Scalars['Int']['input'];
-  spaceId: Scalars['UUID']['input'];
+export type ClaimResponseSummariesQueryVariables = Exact<{
+  filter: UserVoteFilter;
+  first: number;
+  offset: number;
 }>;
 
 
-export type EntityVotersQuery = { __typename?: 'Query', userVotes?: Array<{ __typename?: 'UserVote', userId: any, voteType: number }> | null };
+export type ClaimResponseSummariesQuery = { userVotes: Array<{ userId: any, objectId: any, voteType: number, voteKind: number }> | null };
 
 export type UserHasEntityVoteQueryVariables = Exact<{
-  userId: Scalars['UUID']['input'];
+  userId: any;
 }>;
 
 
-export type UserHasEntityVoteQuery = { __typename?: 'Query', userVotes?: Array<{ __typename?: 'UserVote', userId: any }> | null };
+export type UserHasEntityVoteQuery = { userVotes: Array<{ userId: any }> | null };
 
 export const RelationToEntityFragmentDoc = {"kind":"Document","definitions":[{"kind":"FragmentDefinition","name":{"kind":"Name","value":"RelationToEntity"},"typeCondition":{"kind":"NamedType","name":{"kind":"Name","value":"Entity"}},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"types"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}}]}},{"kind":"Field","name":{"kind":"Name","value":"valuesList"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"propertyId"}},{"kind":"Field","name":{"kind":"Name","value":"text"}}]}}]}}]} as unknown as DocumentNode<RelationToEntityFragment, unknown>;
 export const RelationFieldsFragmentDoc = {"kind":"Document","definitions":[{"kind":"FragmentDefinition","name":{"kind":"Name","value":"RelationFields"},"typeCondition":{"kind":"NamedType","name":{"kind":"Name","value":"Relation"}},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"position"}},{"kind":"Field","name":{"kind":"Name","value":"verified"}},{"kind":"Field","name":{"kind":"Name","value":"entityId"}},{"kind":"Field","name":{"kind":"Name","value":"fromEntity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}}]}},{"kind":"Field","name":{"kind":"Name","value":"toEntity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"FragmentSpread","name":{"kind":"Name","value":"RelationToEntity"}}]}},{"kind":"Field","name":{"kind":"Name","value":"toSpaceId"}},{"kind":"Field","name":{"kind":"Name","value":"type"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}}]}}]}},{"kind":"FragmentDefinition","name":{"kind":"Name","value":"RelationToEntity"},"typeCondition":{"kind":"NamedType","name":{"kind":"Name","value":"Entity"}},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"types"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}}]}},{"kind":"Field","name":{"kind":"Name","value":"valuesList"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"propertyId"}},{"kind":"Field","name":{"kind":"Name","value":"text"}}]}}]}}]} as unknown as DocumentNode<RelationFieldsFragment, unknown>;
@@ -7156,7 +1598,8 @@ export const EntitiesPageDocument = {"kind":"Document","definitions":[{"kind":"O
 export const ImportNameValuesDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"ImportNameValues"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"propertyId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"texts"}},"type":{"kind":"ListType","type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"String"}}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"first"}},"type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"entityFilter"}},"type":{"kind":"NamedType","name":{"kind":"Name","value":"EntityFilter"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"values"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"condition"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"propertyId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"propertyId"}}}]}},{"kind":"Argument","name":{"kind":"Name","value":"filter"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"text"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"inInsensitive"},"value":{"kind":"Variable","name":{"kind":"Name","value":"texts"}}}]}},{"kind":"ObjectField","name":{"kind":"Name","value":"entity"},"value":{"kind":"Variable","name":{"kind":"Name","value":"entityFilter"}}}]}},{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"Variable","name":{"kind":"Name","value":"first"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"text"}},{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"entity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"typeIds"}},{"kind":"Field","name":{"kind":"Name","value":"backlinks"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"totalCount"}}]}},{"kind":"Field","name":{"kind":"Name","value":"relations"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"totalCount"}}]}}]}}]}}]}}]} as unknown as DocumentNode<ImportNameValuesQuery, ImportNameValuesQueryVariables>;
 export const EntityTiebreakerBatchDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"EntityTiebreakerBatch"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"filter"}},"type":{"kind":"NamedType","name":{"kind":"Name","value":"EntityFilter"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"entities"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"filter"},"value":{"kind":"Variable","name":{"kind":"Name","value":"filter"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"createdAt"}},{"kind":"Field","name":{"kind":"Name","value":"backlinks"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"totalCount"}}]}},{"kind":"Field","name":{"kind":"Name","value":"relations"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"totalCount"}}]}},{"kind":"Field","name":{"kind":"Name","value":"values"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"totalCount"}}]}}]}}]}}]} as unknown as DocumentNode<EntityTiebreakerBatchQuery, EntityTiebreakerBatchQueryVariables>;
 export const RelationEntityMinimalDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"RelationEntityMinimal"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"id"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"relation"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"id"},"value":{"kind":"Variable","name":{"kind":"Name","value":"id"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"entity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"description"}},{"kind":"Field","name":{"kind":"Name","value":"spaceIds"}},{"kind":"Field","name":{"kind":"Name","value":"types"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}}]}},{"kind":"Field","alias":{"kind":"Name","value":"allValuesList"},"name":{"kind":"Name","value":"valuesList"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"IntValue","value":"1000"}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"propertyId"}}]}},{"kind":"Field","alias":{"kind":"Name","value":"allRelationsList"},"name":{"kind":"Name","value":"relationsList"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"IntValue","value":"1000"}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}}]}},{"kind":"Field","name":{"kind":"Name","value":"valuesList"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"IntValue","value":"1000"}},{"kind":"Argument","name":{"kind":"Name","value":"filter"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"is"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}}]}}]}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"property"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"dataTypeId"}},{"kind":"Field","name":{"kind":"Name","value":"dataTypeName"}},{"kind":"Field","name":{"kind":"Name","value":"renderableTypeId"}},{"kind":"Field","name":{"kind":"Name","value":"renderableTypeName"}},{"kind":"Field","name":{"kind":"Name","value":"format"}}]}},{"kind":"Field","name":{"kind":"Name","value":"text"}},{"kind":"Field","name":{"kind":"Name","value":"integer"}},{"kind":"Field","name":{"kind":"Name","value":"float"}},{"kind":"Field","name":{"kind":"Name","value":"point"}},{"kind":"Field","name":{"kind":"Name","value":"boolean"}},{"kind":"Field","name":{"kind":"Name","value":"time"}},{"kind":"Field","name":{"kind":"Name","value":"language"}},{"kind":"Field","name":{"kind":"Name","value":"unit"}},{"kind":"Field","name":{"kind":"Name","value":"datetime"}},{"kind":"Field","name":{"kind":"Name","value":"date"}},{"kind":"Field","name":{"kind":"Name","value":"decimal"}},{"kind":"Field","name":{"kind":"Name","value":"schedule"}}]}},{"kind":"Field","name":{"kind":"Name","value":"relationsList"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"IntValue","value":"1000"}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"verified"}},{"kind":"Field","name":{"kind":"Name","value":"toSpaceId"}},{"kind":"Field","name":{"kind":"Name","value":"position"}},{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"entityId"}},{"kind":"Field","name":{"kind":"Name","value":"fromEntity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}}]}},{"kind":"Field","name":{"kind":"Name","value":"toEntity"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"FragmentSpread","name":{"kind":"Name","value":"RelationToEntity"}}]}},{"kind":"Field","name":{"kind":"Name","value":"type"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"description"}}]}}]}}]}}]}}]}},{"kind":"FragmentDefinition","name":{"kind":"Name","value":"RelationToEntity"},"typeCondition":{"kind":"NamedType","name":{"kind":"Name","value":"Entity"}},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"types"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"id"}}]}},{"kind":"Field","name":{"kind":"Name","value":"valuesList"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"propertyId"}},{"kind":"Field","name":{"kind":"Name","value":"text"}}]}}]}}]} as unknown as DocumentNode<RelationEntityMinimalQuery, RelationEntityMinimalQueryVariables>;
-export const EntityVoteCountDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"EntityVoteCount"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"votesCountsConnection"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"condition"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}}]}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"nodes"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"spaceId"}},{"kind":"Field","name":{"kind":"Name","value":"upvotes"}},{"kind":"Field","name":{"kind":"Name","value":"downvotes"}}]}}]}}]}}]} as unknown as DocumentNode<EntityVoteCountQuery, EntityVoteCountQueryVariables>;
-export const UserEntityVoteDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"UserEntityVote"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"userId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"userId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"userId"}}},{"kind":"Argument","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"Argument","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}},{"kind":"Argument","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"voteType"}}]}}]}}]} as unknown as DocumentNode<UserEntityVoteQuery, UserEntityVoteQueryVariables>;
-export const EntityVotersDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"EntityVoters"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVotes"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"condition"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}}]}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userId"}},{"kind":"Field","name":{"kind":"Name","value":"voteType"}}]}}]}}]} as unknown as DocumentNode<EntityVotersQuery, EntityVotersQueryVariables>;
+export const EntityResponseCountsDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"EntityResponseCounts"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"Argument","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}},{"kind":"Argument","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}},{"kind":"Argument","name":{"kind":"Name","value":"voteKind"},"value":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"positive"}},{"kind":"Field","name":{"kind":"Name","value":"negative"}},{"kind":"Field","name":{"kind":"Name","value":"voteKind"}}]}}]}}]} as unknown as DocumentNode<EntityResponseCountsQuery, EntityResponseCountsQueryVariables>;
+export const UserEntityResponseDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"UserEntityResponse"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"userId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"userId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"userId"}}},{"kind":"Argument","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"Argument","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}},{"kind":"Argument","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}},{"kind":"Argument","name":{"kind":"Name","value":"voteKind"},"value":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"voteType"}}]}}]}}]} as unknown as DocumentNode<UserEntityResponseQuery, UserEntityResponseQueryVariables>;
+export const EntityRespondersDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"EntityResponders"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVotes"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"condition"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"objectId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectId"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"objectType"},"value":{"kind":"Variable","name":{"kind":"Name","value":"objectType"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"spaceId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"spaceId"}}},{"kind":"ObjectField","name":{"kind":"Name","value":"voteKind"},"value":{"kind":"Variable","name":{"kind":"Name","value":"voteKind"}}}]}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userId"}},{"kind":"Field","name":{"kind":"Name","value":"voteType"}}]}}]}}]} as unknown as DocumentNode<EntityRespondersQuery, EntityRespondersQueryVariables>;
+export const ClaimResponseSummariesDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"ClaimResponseSummaries"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"filter"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UserVoteFilter"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"first"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}},{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"offset"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"Int"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVotes"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"filter"},"value":{"kind":"Variable","name":{"kind":"Name","value":"filter"}}},{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"Variable","name":{"kind":"Name","value":"first"}}},{"kind":"Argument","name":{"kind":"Name","value":"offset"},"value":{"kind":"Variable","name":{"kind":"Name","value":"offset"}}},{"kind":"Argument","name":{"kind":"Name","value":"orderBy"},"value":{"kind":"ListValue","values":[{"kind":"EnumValue","value":"OBJECT_ID_ASC"},{"kind":"EnumValue","value":"VOTE_KIND_ASC"},{"kind":"EnumValue","value":"USER_ID_ASC"}]}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userId"}},{"kind":"Field","name":{"kind":"Name","value":"objectId"}},{"kind":"Field","name":{"kind":"Name","value":"voteType"}},{"kind":"Field","name":{"kind":"Name","value":"voteKind"}}]}}]}}]} as unknown as DocumentNode<ClaimResponseSummariesQuery, ClaimResponseSummariesQueryVariables>;
 export const UserHasEntityVoteDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"UserHasEntityVote"},"variableDefinitions":[{"kind":"VariableDefinition","variable":{"kind":"Variable","name":{"kind":"Name","value":"userId"}},"type":{"kind":"NonNullType","type":{"kind":"NamedType","name":{"kind":"Name","value":"UUID"}}}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userVotes"},"arguments":[{"kind":"Argument","name":{"kind":"Name","value":"condition"},"value":{"kind":"ObjectValue","fields":[{"kind":"ObjectField","name":{"kind":"Name","value":"userId"},"value":{"kind":"Variable","name":{"kind":"Name","value":"userId"}}}]}},{"kind":"Argument","name":{"kind":"Name","value":"first"},"value":{"kind":"IntValue","value":"1"}}],"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"userId"}}]}}]}}]} as unknown as DocumentNode<UserHasEntityVoteQuery, UserHasEntityVoteQueryVariables>;
\ No newline at end of file
diff --git a/apps/web/core/hooks/use-entity-vote.test.tsx b/apps/web/core/hooks/use-entity-vote.test.tsx
new file mode 100644
index 0000000000..64433b5e7a
--- /dev/null
+++ b/apps/web/core/hooks/use-entity-vote.test.tsx
@@ -0,0 +1,539 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, cleanup, renderHook } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { entityResponseIndexingQueryKey } from '~/core/responses/entity-response';
+
+import {
+  useEntityResponse,
+  useEntityResponseIndexingSnapshot,
+  useEntityResponseIndexingState,
+} from './use-entity-vote';
+
+const PERSONAL_SPACE_ID = 'd4bee0928fb5405baba3b1513f085835';
+const TARGET_SPACE_ID = '1234567890abcdef1234567890abcdef';
+
+const mocks = vi.hoisted(() => ({
+  fetchResponse:
+    vi.fn<(signal?: AbortSignal) => 'positive' | 'negative' | null | Promise<'positive' | 'negative' | null>>(),
+  runEffectEither: vi.fn(),
+  responseAction: vi.fn(() => ({ to: '0x1234' as const, calldata: '0xabcd' as const })),
+  waitForIndexedEntityResponse: vi.fn(),
+  loadResponseSummaryCaches: vi.fn(),
+  personalSpaceId: 'd4bee0928fb5405baba3b1513f085835' as string | null,
+}));
+
+vi.mock('~/core/responses/entity-response', async importOriginal => {
+  const actual = await importOriginal<typeof import('~/core/responses/entity-response')>();
+  mocks.waitForIndexedEntityResponse.mockImplementation(actual.waitForIndexedEntityResponse);
+  return {
+    ...actual,
+    waitForIndexedEntityResponse: (...args: Parameters<typeof actual.waitForIndexedEntityResponse>) =>
+      mocks.waitForIndexedEntityResponse(...args),
+  };
+});
+
+vi.mock('~/core/hooks/use-personal-space-id', () => ({
+  usePersonalSpaceId: () => ({ personalSpaceId: mocks.personalSpaceId, isRegistered: mocks.personalSpaceId !== null }),
+}));
+
+vi.mock('~/core/hooks/use-smart-account-transaction', async () => {
+  const { Effect } = await import('effect');
+  return { useSmartAccountTransaction: () => () => Effect.succeed('0xtransaction') };
+});
+
+vi.mock('~/core/io/queries', async () => {
+  const { Effect } = await import('effect');
+  return {
+    getUserEntityResponse: (...args: unknown[]) =>
+      Effect.tryPromise(() => Promise.resolve(mocks.fetchResponse(args[5] as AbortSignal | undefined))),
+  };
+});
+
+vi.mock('~/core/sdk/geo-client', () => ({
+  geo: {
+    responses: {
+      upvote: mocks.responseAction,
+      downvote: mocks.responseAction,
+      unvote: mocks.responseAction,
+      agree: mocks.responseAction,
+      disagree: mocks.responseAction,
+      unagree: mocks.responseAction,
+      verify: mocks.responseAction,
+      dispute: mocks.responseAction,
+      unverify: mocks.responseAction,
+    },
+  },
+}));
+
+vi.mock('~/core/responses/claim-response-summaries', () => ({
+  claimResponseSummariesQueryKeyPrefix: (personalSpaceId: string | null, spaceId: string) => [
+    'claim-response-summaries',
+    personalSpaceId,
+    spaceId,
+  ],
+  loadClaimResponseSummaryCaches: (...args: unknown[]) => mocks.loadResponseSummaryCaches(...args),
+}));
+
+vi.mock('~/core/telemetry/effect-runtime', () => ({
+  runEffectEither: (...args: unknown[]) => mocks.runEffectEither(...args),
+}));
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  mocks.fetchResponse.mockReset();
+  mocks.runEffectEither.mockReset();
+  mocks.responseAction.mockClear();
+  mocks.waitForIndexedEntityResponse.mockClear();
+  mocks.loadResponseSummaryCaches.mockReset();
+  mocks.loadResponseSummaryCaches.mockResolvedValue(new Map());
+  mocks.runEffectEither.mockResolvedValue({ _tag: 'Right', right: '0xtransaction' });
+  mocks.personalSpaceId = PERSONAL_SPACE_ID;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.useRealTimers();
+});
+
+describe('useEntityResponse indexing reconciliation', () => {
+  it('exposes the expected optimistic response before the transaction settles', async () => {
+    const transaction = deferred<unknown>();
+    mocks.runEffectEither.mockReturnValue(transaction.promise);
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        response: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexing: useEntityResponseIndexingSnapshot({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.response.submitResponse('negative'));
+    await act(async () => Promise.resolve());
+
+    expect(result.current.indexing).toMatchObject({
+      status: 'reconciling',
+      pending: { expectedResponse: 'negative' },
+    });
+  });
+
+  it('keeps a submitted response unsettled and retries automatically after reconciliation exhausts', async () => {
+    mocks.fetchResponse.mockReturnValue(null);
+    const onSuccess = vi.fn();
+    const onError = vi.fn();
+    const { queryClient, wrapper } = createHarness();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const cancelQueries = vi.spyOn(queryClient, 'cancelQueries');
+    const { result } = renderHook(
+      () => useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+      { wrapper }
+    );
+
+    act(() => result.current.submitResponse('positive', { onSuccess, onError }));
+    await act(async () => Promise.resolve());
+
+    expect(onSuccess).toHaveBeenCalledOnce();
+    expect(onError).not.toHaveBeenCalled();
+    expect(result.current.isProcessingResponse).toBe(true);
+    expect(result.current.isResponseIndexingDelayed).toBe(false);
+    const initialRunId = queryClient.getQueryData<{ runId: string }>(
+      entityResponseIndexingQueryKey(PERSONAL_SPACE_ID, 'claim-1', TARGET_SPACE_ID, 'stance')
+    )?.runId;
+
+    await act(async () => vi.advanceTimersByTimeAsync(58_000));
+
+    expect(mocks.fetchResponse).toHaveBeenCalledTimes(30);
+    expect(result.current.isProcessingResponse).toBe(true);
+    expect(result.current.isResponseIndexingDelayed).toBe(true);
+    expect(invalidateQueries).not.toHaveBeenCalled();
+    expect(
+      queryClient.getQueryData<{ runId: string }>(
+        entityResponseIndexingQueryKey(PERSONAL_SPACE_ID, 'claim-1', TARGET_SPACE_ID, 'stance')
+      )?.runId
+    ).toBe(initialRunId);
+
+    mocks.fetchResponse.mockReturnValue('positive');
+    await act(async () => vi.advanceTimersByTimeAsync(10_000));
+
+    expect(result.current.isProcessingResponse).toBe(false);
+    expect(result.current.isResponseIndexingDelayed).toBe(false);
+    expect(result.current.optimisticResponse).toBeUndefined();
+    expect(mocks.loadResponseSummaryCaches).toHaveBeenCalledWith(
+      expect.objectContaining({
+        queryClient,
+        spaceId: TARGET_SPACE_ID,
+        personalSpaceId: PERSONAL_SPACE_ID,
+        targets: [{ entityId: 'claim-1', responseKind: 'stance' }],
+      })
+    );
+    expect(cancelQueries).toHaveBeenCalledWith({
+      queryKey: ['claim-response-summaries', PERSONAL_SPACE_ID, TARGET_SPACE_ID],
+    });
+    expect(invalidateQueries).not.toHaveBeenCalled();
+  });
+
+  it('isolates optimistic response state by personal space', async () => {
+    const transaction = deferred<unknown>();
+    mocks.runEffectEither.mockReturnValue(transaction.promise);
+    const { wrapper } = createHarness();
+    const { result, rerender } = renderHook(
+      () => useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+      { wrapper }
+    );
+
+    act(() => result.current.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+    expect(result.current.optimisticResponse).toBe('positive');
+
+    mocks.personalSpaceId = 'another-personal-space';
+    rerender();
+
+    expect(result.current.optimisticResponse).toBeUndefined();
+  });
+
+  it('stays visibly processing after submission and invalidates when Gaia indexes late', async () => {
+    let fetchCount = 0;
+    mocks.fetchResponse.mockImplementation(() => (++fetchCount >= 2 ? 'positive' : null));
+    const { queryClient, wrapper } = createHarness();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const { result } = renderHook(
+      () => useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+      { wrapper }
+    );
+
+    act(() => result.current.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+    expect(result.current.isProcessingResponse).toBe(true);
+    expect(result.current.isResponseIndexingDelayed).toBe(false);
+    expect(invalidateQueries).not.toHaveBeenCalled();
+
+    await act(async () => vi.advanceTimersByTimeAsync(2_000));
+
+    expect(mocks.fetchResponse).toHaveBeenCalledTimes(2);
+    expect(result.current.isProcessingResponse).toBe(false);
+    expect(result.current.isResponseIndexingDelayed).toBe(false);
+    expect(result.current.optimisticResponse).toBeUndefined();
+    expect(mocks.loadResponseSummaryCaches).toHaveBeenCalledOnce();
+    expect(invalidateQueries).not.toHaveBeenCalled();
+  });
+
+  it('keeps reconciliation recoverable when the single-claim summary refresh fails', async () => {
+    mocks.fetchResponse.mockReturnValue('positive');
+    mocks.loadResponseSummaryCaches.mockRejectedValueOnce(new Error('summary unavailable'));
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+      { wrapper }
+    );
+
+    act(() => result.current.submitResponse('positive'));
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(result.current.isResponseIndexingDelayed).toBe(true);
+    expect(mocks.loadResponseSummaryCaches).toHaveBeenCalledOnce();
+
+    await act(async () => vi.advanceTimersByTimeAsync(10_000));
+
+    expect(mocks.loadResponseSummaryCaches).toHaveBeenCalledTimes(2);
+    expect(result.current.isResponseIndexingDelayed).toBe(false);
+  });
+
+  it('preserves individual cache invalidation for non-Claim curation votes', async () => {
+    mocks.fetchResponse.mockReturnValue('positive');
+    const { queryClient, wrapper } = createHarness();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const { result } = renderHook(
+      () => useEntityResponse({ entityId: 'entity-1', spaceId: TARGET_SPACE_ID, responseKind: 'curation' }),
+      { wrapper }
+    );
+
+    act(() => result.current.submitResponse('positive'));
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(mocks.loadResponseSummaryCaches).not.toHaveBeenCalled();
+    expect(invalidateQueries).toHaveBeenCalledTimes(3);
+  });
+
+  it('does not let an older control supersede shared indexing state', async () => {
+    const firstTransaction = deferred<unknown>();
+    const secondTransaction = deferred<unknown>();
+    mocks.runEffectEither.mockReturnValueOnce(firstTransaction.promise).mockReturnValueOnce(secondTransaction.promise);
+    mocks.fetchResponse.mockReturnValue(null);
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        first: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        second: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexingStatus: useEntityResponseIndexingState({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.first.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+    act(() => result.current.second.submitResponse('negative'));
+    await act(async () => Promise.resolve());
+    expect(result.current.first.optimisticResponse).toBe('negative');
+
+    await act(async () => {
+      secondTransaction.resolve({ _tag: 'Right', right: '0xsecond' });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+    expect(result.current.indexingStatus).toBe('reconciling');
+    expect(result.current.first.optimisticResponse).toBe('negative');
+
+    await act(async () => {
+      firstTransaction.resolve({ _tag: 'Right', right: '0xfirst' });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+    expect(result.current.indexingStatus).toBe('reconciling');
+  });
+
+  it('resumes an older successful submission when a newer transaction fails', async () => {
+    const firstTransaction = deferred<unknown>();
+    const secondTransaction = deferred<unknown>();
+    mocks.runEffectEither.mockReturnValueOnce(firstTransaction.promise).mockReturnValueOnce(secondTransaction.promise);
+    mocks.fetchResponse.mockReturnValue('positive');
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        first: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        second: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexingStatus: useEntityResponseIndexingState({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.first.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+    act(() => result.current.second.submitResponse('negative'));
+    await act(async () => Promise.resolve());
+
+    await act(async () => {
+      secondTransaction.resolve({ _tag: 'Left', left: new Error('rejected') });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(result.current.indexingStatus).toBe('reconciling');
+    expect(result.current.first.optimisticResponse).toBe('positive');
+
+    await act(async () => {
+      firstTransaction.resolve({ _tag: 'Right', right: '0xfirst' });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+    expect(result.current.indexingStatus).toBe('idle');
+    consoleError.mockRestore();
+  });
+
+  it('resumes the oldest submission after two newer overlapping transactions fail', async () => {
+    const firstTransaction = deferred<unknown>();
+    const secondTransaction = deferred<unknown>();
+    const thirdTransaction = deferred<unknown>();
+    mocks.runEffectEither
+      .mockReturnValueOnce(firstTransaction.promise)
+      .mockReturnValueOnce(secondTransaction.promise)
+      .mockReturnValueOnce(thirdTransaction.promise);
+    mocks.fetchResponse.mockReturnValue('positive');
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        first: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        second: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        third: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexingStatus: useEntityResponseIndexingState({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.first.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+    act(() => result.current.second.submitResponse('negative'));
+    await act(async () => Promise.resolve());
+    act(() => result.current.third.submitResponse('positive'));
+    await act(async () => Promise.resolve());
+
+    await act(async () => {
+      secondTransaction.resolve({ _tag: 'Left', left: new Error('second rejected') });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(result.current.indexingStatus).toBe('reconciling');
+
+    await act(async () => {
+      thirdTransaction.resolve({ _tag: 'Left', left: new Error('third rejected') });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(result.current.indexingStatus).toBe('reconciling');
+    expect(result.current.first.optimisticResponse).toBe('positive');
+
+    await act(async () => {
+      firstTransaction.resolve({ _tag: 'Right', right: '0xfirst' });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+    expect(result.current.indexingStatus).toBe('idle');
+    consoleError.mockRestore();
+  });
+
+  it('aborts an active polling run when another control submits', async () => {
+    mocks.fetchResponse
+      .mockImplementationOnce(
+        signal =>
+          new Promise((_resolve, reject) => {
+            signal?.addEventListener('abort', () => reject(new Error('aborted')));
+          })
+      )
+      .mockReturnValue('negative');
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        first: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        second: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexingStatus: useEntityResponseIndexingState({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.first.submitResponse('positive'));
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.fetchResponse).toHaveBeenCalledOnce();
+
+    act(() => result.current.second.submitResponse('negative'));
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(mocks.fetchResponse).toHaveBeenCalledTimes(2);
+    expect(result.current.indexingStatus).toBe('idle');
+  });
+
+  it('does not let a cancelled attempt clobber a restarted reconciliation for the same submission', async () => {
+    const firstReconciliation = deferred<boolean>();
+    const restartedReconciliation = deferred<boolean>();
+    const secondTransaction = deferred<unknown>();
+    mocks.waitForIndexedEntityResponse
+      .mockImplementationOnce(() => firstReconciliation.promise)
+      .mockImplementationOnce(() => restartedReconciliation.promise);
+    mocks.runEffectEither
+      .mockResolvedValueOnce({ _tag: 'Right', right: '0xfirst' })
+      .mockReturnValueOnce(secondTransaction.promise);
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => ({
+        first: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        second: useEntityResponse({ entityId: 'claim-1', spaceId: TARGET_SPACE_ID, responseKind: 'stance' }),
+        indexingStatus: useEntityResponseIndexingState({
+          entityId: 'claim-1',
+          spaceId: TARGET_SPACE_ID,
+          responseKind: 'stance',
+        }),
+      }),
+      { wrapper }
+    );
+
+    act(() => result.current.first.submitResponse('positive'));
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.waitForIndexedEntityResponse).toHaveBeenCalledOnce();
+
+    act(() => result.current.second.submitResponse('negative'));
+    await act(async () => Promise.resolve());
+    await act(async () => {
+      secondTransaction.resolve({ _tag: 'Left', left: new Error('second rejected') });
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(mocks.waitForIndexedEntityResponse).toHaveBeenCalledTimes(2);
+
+    await act(async () => {
+      firstReconciliation.resolve(false);
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(result.current.indexingStatus).toBe('reconciling');
+
+    await act(async () => {
+      restartedReconciliation.resolve(true);
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(result.current.indexingStatus).toBe('idle');
+    consoleError.mockRestore();
+  });
+});
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>(resolvePromise => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+
+function createHarness() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      mutations: { retry: false },
+      queries: { retry: false },
+    },
+  });
+
+  return {
+    queryClient,
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  };
+}
diff --git a/apps/web/core/hooks/use-entity-vote.ts b/apps/web/core/hooks/use-entity-vote.ts
index 2b863630bf..11abddd92f 100644
--- a/apps/web/core/hooks/use-entity-vote.ts
+++ b/apps/web/core/hooks/use-entity-vote.ts
@@ -1,42 +1,290 @@
 'use client';
 
-import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { hashKey, useMutation, useQueryClient } from '@tanstack/react-query';
 
-import { useCallback } from 'react';
+import { useCallback, useEffect, useMemo, useSyncExternalStore } from 'react';
 
 import { Effect, Either } from 'effect';
 
 import { usePersonalSpaceId } from '~/core/hooks/use-personal-space-id';
 import { useSmartAccountTransaction } from '~/core/hooks/use-smart-account-transaction';
+import { getUserEntityResponse } from '~/core/io/queries';
+import {
+  claimResponseSummariesQueryKeyPrefix,
+  loadClaimResponseSummaryCaches,
+} from '~/core/responses/claim-response-summaries';
+import {
+  type ActiveResponseDirection,
+  type ResponseDirection,
+  type ResponseKind,
+  entityRespondersQueryKey,
+  entityResponseCountsQueryKey,
+  entityResponseIndexingQueryKey,
+  getResponseActionMethod,
+  userEntityResponseQueryKey,
+  waitForIndexedEntityResponse,
+} from '~/core/responses/entity-response';
 import { geo } from '~/core/sdk/geo-client';
 import { runEffectEither } from '~/core/telemetry/effect-runtime';
-import type { VoteDirection, VoteObjectType } from '~/core/utils/contracts/entity-vote';
 import { validateSpaceId } from '~/core/utils/utils';
 
-export type { VoteDirection, VoteObjectType };
+interface UseEntityResponseArgs {
+  entityId: string;
+  spaceId: string;
+  responseKind: ResponseKind | null;
+}
 
-// The SDK's entityVotes.upvote/downvote/withdraw hardcode object type 0 in the
-// vote topic, so this hook deliberately has no objectType parameter — accepting
-// one would let a caller read type-N tallies while writing type-0 votes.
-interface UseEntityVoteArgs {
+export type PendingEntityResponseIndex = {
   entityId: string;
+  expectedResponse: ActiveResponseDirection | null;
+  personalSpaceId: string;
+  responseKind: ResponseKind;
   spaceId: string;
+};
+
+export type EntityResponseIndexingState =
+  | { status: 'idle'; pending: null; runId: null }
+  | { status: 'reconciling'; pending: PendingEntityResponseIndex | null; runId: string }
+  | { status: 'delayed'; pending: PendingEntityResponseIndex; runId: string }
+  | { status: 'indexed'; pending: PendingEntityResponseIndex; runId: string };
+
+const IDLE_INDEXING_STATE: EntityResponseIndexingState = { status: 'idle', pending: null, runId: null };
+let responseIndexingRunSequence = 0;
+type ResponseSubmissionRun = {
+  pending: PendingEntityResponseIndex | null;
+  previousState: EntityResponseIndexingState;
+  runId: string;
+  runOrder: number;
+  status: 'pending' | 'success' | 'failed';
+};
+type ResponseIndexingRegistry = {
+  activeReconciliations: Map<string, { controller: AbortController; runId: string }>;
+  submissionRuns: Map<string, Map<string, ResponseSubmissionRun>>;
+};
+const responseIndexingRegistries = new WeakMap<object, ResponseIndexingRegistry>();
+
+function createResponseIndexingRunId() {
+  responseIndexingRunSequence += 1;
+  return {
+    runId: `${Date.now()}-${responseIndexingRunSequence}`,
+    runOrder: responseIndexingRunSequence,
+  };
+}
+
+function getResponseIndexingRegistry(queryClient: object) {
+  let registry = responseIndexingRegistries.get(queryClient);
+  if (!registry) {
+    registry = { activeReconciliations: new Map(), submissionRuns: new Map() };
+    responseIndexingRegistries.set(queryClient, registry);
+  }
+  return registry;
+}
+
+function cancelActiveResponseReconciliation(registry: ResponseIndexingRegistry, indexingKeyId: string) {
+  registry.activeReconciliations.get(indexingKeyId)?.controller.abort();
+  registry.activeReconciliations.delete(indexingKeyId);
+}
+
+function getResponseSubmissionRuns(registry: ResponseIndexingRegistry, indexingKeyId: string) {
+  let runs = registry.submissionRuns.get(indexingKeyId);
+  if (!runs) {
+    runs = new Map();
+    registry.submissionRuns.set(indexingKeyId, runs);
+  }
+  return runs;
+}
+
+export function useEntityResponseIndexingState({
+  entityId,
+  spaceId,
+  responseKind,
+}: UseEntityResponseArgs): 'idle' | 'reconciling' | 'delayed' {
+  const status = useEntityResponseIndexingSnapshot({ entityId, spaceId, responseKind }).status;
+  return status === 'indexed' ? 'idle' : status;
+}
+
+export function useEntityResponseIndexingSnapshot({ entityId, spaceId, responseKind }: UseEntityResponseArgs) {
+  const queryClient = useQueryClient();
+  const { personalSpaceId } = usePersonalSpaceId();
+  const queryKey = useMemo(
+    () => entityResponseIndexingQueryKey(personalSpaceId, entityId, spaceId, responseKind),
+    [entityId, personalSpaceId, responseKind, spaceId]
+  );
+  const queryHash = useMemo(() => hashKey(queryKey), [queryKey]);
+  const getSnapshot = useCallback(
+    () => queryClient.getQueryData<EntityResponseIndexingState>(queryKey) ?? IDLE_INDEXING_STATE,
+    [queryClient, queryKey]
+  );
+  const subscribe = useCallback(
+    (onStoreChange: () => void) =>
+      queryClient.getQueryCache().subscribe(event => {
+        if (event.query.queryHash === queryHash) onStoreChange();
+      }),
+    [queryClient, queryHash]
+  );
+
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
 
-export function useEntityVote({ entityId, spaceId }: UseEntityVoteArgs) {
+export function useResetEntityResponseIndexingSnapshot({ entityId, spaceId, responseKind }: UseEntityResponseArgs) {
   const queryClient = useQueryClient();
+  const { personalSpaceId } = usePersonalSpaceId();
+  const queryKey = useMemo(
+    () => entityResponseIndexingQueryKey(personalSpaceId, entityId, spaceId, responseKind),
+    [entityId, personalSpaceId, responseKind, spaceId]
+  );
+
+  return useCallback(
+    (runId: string) => {
+      queryClient.setQueryData<EntityResponseIndexingState>(queryKey, current =>
+        current?.runId === runId ? IDLE_INDEXING_STATE : current
+      );
+    },
+    [queryClient, queryKey]
+  );
+}
+
+export function useEntityResponse({ entityId, spaceId, responseKind }: UseEntityResponseArgs) {
+  const queryClient = useQueryClient();
+  const responseIndexingRegistry = getResponseIndexingRegistry(queryClient);
   const { personalSpaceId, isRegistered } = usePersonalSpaceId();
+  const indexingQueryKey = useMemo(
+    () => entityResponseIndexingQueryKey(personalSpaceId, entityId, spaceId, responseKind),
+    [entityId, personalSpaceId, responseKind, spaceId]
+  );
+  const indexingKeyId = useMemo(() => hashKey(indexingQueryKey), [indexingQueryKey]);
+  const indexingState = useEntityResponseIndexingSnapshot({ entityId, spaceId, responseKind });
 
   const tx = useSmartAccountTransaction();
 
-  const castVote = useCallback(
-    async (direction: VoteDirection) => {
+  const pendingResponseIndex = useCallback(
+    (direction: ResponseDirection): PendingEntityResponseIndex | null => {
+      if (!responseKind || !personalSpaceId || !isRegistered || !validateSpaceId(spaceId)) return null;
+
+      return {
+        entityId,
+        expectedResponse: direction === 'clear' ? null : direction,
+        personalSpaceId,
+        responseKind,
+        spaceId,
+      };
+    },
+    [entityId, isRegistered, personalSpaceId, responseKind, spaceId]
+  );
+
+  const isCurrentIndexingRun = useCallback(
+    (runId: string) => queryClient.getQueryData<EntityResponseIndexingState>(indexingQueryKey)?.runId === runId,
+    [indexingQueryKey, queryClient]
+  );
+
+  const reconcileResponseIndexing = useCallback(
+    async (pending: PendingEntityResponseIndex, runId: string) => {
+      if (!isCurrentIndexingRun(runId)) return;
+      cancelActiveResponseReconciliation(responseIndexingRegistry, indexingKeyId);
+      const controller = new AbortController();
+      responseIndexingRegistry.activeReconciliations.set(indexingKeyId, { controller, runId });
+
+      const indexed = await waitForIndexedEntityResponse(
+        signal =>
+          Effect.runPromise(
+            getUserEntityResponse(
+              pending.personalSpaceId,
+              pending.entityId,
+              pending.spaceId,
+              pending.responseKind,
+              0,
+              signal
+            )
+          ),
+        pending.expectedResponse,
+        30,
+        2_000,
+        5_000,
+        controller.signal
+      );
+
+      const activeReconciliation = responseIndexingRegistry.activeReconciliations.get(indexingKeyId);
+      if (activeReconciliation?.controller !== controller) return;
+      responseIndexingRegistry.activeReconciliations.delete(indexingKeyId);
+
+      if (!isCurrentIndexingRun(runId)) return;
+
+      if (!indexed) {
+        queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+          status: 'delayed',
+          pending,
+          runId,
+        });
+        responseIndexingRegistry.submissionRuns.delete(indexingKeyId);
+        return;
+      }
+
+      try {
+        if (pending.responseKind === 'curation') {
+          await Promise.all([
+            queryClient.invalidateQueries({
+              queryKey: entityResponseCountsQueryKey(pending.entityId, pending.spaceId, 0, pending.responseKind),
+            }),
+            queryClient.invalidateQueries({
+              queryKey: userEntityResponseQueryKey(
+                pending.personalSpaceId,
+                pending.entityId,
+                pending.spaceId,
+                0,
+                pending.responseKind
+              ),
+            }),
+            queryClient.invalidateQueries({
+              queryKey: entityRespondersQueryKey(pending.entityId, pending.spaceId, 0, pending.responseKind),
+            }),
+          ]);
+        } else {
+          void queryClient.cancelQueries({
+            queryKey: claimResponseSummariesQueryKeyPrefix(pending.personalSpaceId, pending.spaceId),
+          });
+          await loadClaimResponseSummaryCaches({
+            queryClient,
+            spaceId: pending.spaceId,
+            targets: [{ entityId: pending.entityId, responseKind: pending.responseKind }],
+            personalSpaceId: pending.personalSpaceId,
+            signal: controller.signal,
+            forceResponseRefresh: true,
+          });
+        }
+      } catch {
+        if (!isCurrentIndexingRun(runId)) return;
+        queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+          status: 'delayed',
+          pending,
+          runId,
+        });
+        responseIndexingRegistry.submissionRuns.delete(indexingKeyId);
+        return;
+      }
+      if (!isCurrentIndexingRun(runId)) return;
+
+      queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+        status: 'indexed',
+        pending,
+        runId,
+      });
+      responseIndexingRegistry.submissionRuns.delete(indexingKeyId);
+    },
+    [indexingKeyId, indexingQueryKey, isCurrentIndexingRun, queryClient, responseIndexingRegistry]
+  );
+
+  const executeResponse = useCallback(
+    async (direction: ResponseDirection) => {
+      if (!responseKind) {
+        throw new Error('Response type is unavailable. Cannot submit response.');
+      }
+
       if (!validateSpaceId(spaceId)) {
-        throw new Error('Invalid space ID format. Cannot submit vote.');
+        throw new Error('Invalid space ID format. Cannot submit response.');
       }
 
       if (!personalSpaceId || !isRegistered) {
-        throw new Error('You need a registered personal space to vote');
+        throw new Error('You need a registered personal space to respond');
       }
 
       const params = {
@@ -45,19 +293,16 @@ export function useEntityVote({ entityId, spaceId }: UseEntityVoteArgs) {
         entityId,
       };
 
-      const { to, calldata } =
-        direction === 'UP'
-          ? geo.entityVotes.upvote(params)
-          : direction === 'DOWN'
-            ? geo.entityVotes.downvote(params)
-            : geo.entityVotes.withdraw(params);
+      const action = getResponseActionMethod(responseKind, direction);
+      const { to, calldata } = geo.responses[action](params);
 
       const txEffect = tx({ to, data: calldata }).pipe(
-        Effect.withSpan('web.write.entity_vote'),
+        Effect.withSpan('web.write.entity_response'),
         Effect.annotateSpans({
-          'io.operation': 'entity_vote',
-          'vote.direction': direction,
-          'vote.objectType': '0',
+          'io.operation': 'entity_response',
+          'response.kind': responseKind,
+          'response.direction': direction,
+          'response.objectType': '0',
         })
       );
       const result = await runEffectEither(txEffect);
@@ -65,42 +310,117 @@ export function useEntityVote({ entityId, spaceId }: UseEntityVoteArgs) {
       if (Either.isLeft(result)) {
         const error = result.left;
         console.error(
-          `Entity vote failed: ${error.message}`,
-          { authorSpaceId: personalSpaceId, spaceId, entityId, direction },
+          `Entity response failed: ${error.message}`,
+          { authorSpaceId: personalSpaceId, spaceId, entityId, responseKind, direction },
           error
         );
         throw error;
       }
 
-      return result.right;
+      const pending = pendingResponseIndex(direction);
+      if (!pending) throw new Error('Response indexing context is unavailable.');
+      return { pending, transaction: result.right };
     },
-    [personalSpaceId, isRegistered, spaceId, entityId, tx]
+    [personalSpaceId, isRegistered, spaceId, entityId, responseKind, tx, pendingResponseIndex]
   );
 
-  const onSuccess = () => {
-    queryClient.invalidateQueries({ queryKey: ['entity-vote-count', entityId, 0] });
-    queryClient.invalidateQueries({ queryKey: ['user-entity-vote', personalSpaceId, entityId, spaceId, 0] });
-  };
+  const responseMutation = useMutation({
+    mutationFn: executeResponse,
+    onMutate: direction => {
+      const previousState =
+        queryClient.getQueryData<EntityResponseIndexingState>(indexingQueryKey) ?? IDLE_INDEXING_STATE;
+      const { runId, runOrder } = createResponseIndexingRunId();
+      const pending = pendingResponseIndex(direction);
+      getResponseSubmissionRuns(responseIndexingRegistry, indexingKeyId).set(runId, {
+        pending,
+        previousState,
+        runId,
+        runOrder,
+        status: 'pending',
+      });
+      cancelActiveResponseReconciliation(responseIndexingRegistry, indexingKeyId);
+      queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+        status: 'reconciling',
+        pending,
+        runId,
+      });
+      return { previousState, runId, runOrder };
+    },
+    onSuccess: (submission, _direction, context) => {
+      if (!context) return;
+      const run = responseIndexingRegistry.submissionRuns.get(indexingKeyId)?.get(context.runId);
+      if (!run) return;
+      run.pending = submission.pending;
+      run.status = 'success';
+      if (isCurrentIndexingRun(context.runId)) {
+        void reconcileResponseIndexing(submission.pending, context.runId);
+      }
+    },
+    onError: (_error, _direction, context) => {
+      if (!context) return;
+      const runs = responseIndexingRegistry.submissionRuns.get(indexingKeyId);
+      const failedRun = runs?.get(context.runId);
+      if (!runs || !failedRun) return;
+      failedRun.status = 'failed';
+      if (!isCurrentIndexingRun(context.runId)) return;
 
-  const { mutate: upvote } = useMutation({
-    mutationFn: () => castVote('UP'),
-    onSuccess,
-  });
+      const recoverableRun = [...runs.values()]
+        .filter(run => run.status !== 'failed' && run.runOrder < context.runOrder)
+        .sort((left, right) => right.runOrder - left.runOrder)[0];
+      if (recoverableRun) {
+        queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+          status: 'reconciling',
+          pending: recoverableRun.pending,
+          runId: recoverableRun.runId,
+        });
+        if (recoverableRun.status === 'success' && recoverableRun.pending) {
+          void reconcileResponseIndexing(recoverableRun.pending, recoverableRun.runId);
+        }
+        return;
+      }
 
-  const { mutate: downvote } = useMutation({
-    mutationFn: () => castVote('DOWN'),
-    onSuccess,
+      const previousState = [...runs.values()].sort((left, right) => left.runOrder - right.runOrder)[0]?.previousState;
+      responseIndexingRegistry.submissionRuns.delete(indexingKeyId);
+      if (!previousState || previousState.status === 'idle') {
+        queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, IDLE_INDEXING_STATE);
+        return;
+      }
+      queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, previousState);
+      if (previousState.status === 'reconciling' && previousState.pending) {
+        void reconcileResponseIndexing(previousState.pending, previousState.runId);
+      }
+    },
   });
 
-  const { mutate: unvote } = useMutation({
-    mutationFn: () => castVote('NONE'),
-    onSuccess,
-  });
+  const retryResponseIndexing = useCallback(() => {
+    const current = queryClient.getQueryData<EntityResponseIndexingState>(indexingQueryKey);
+    if (!current?.pending || current.status !== 'delayed') return;
+    const { runId } = current;
+    queryClient.setQueryData<EntityResponseIndexingState>(indexingQueryKey, {
+      status: 'reconciling',
+      pending: current.pending,
+      runId,
+    });
+    void reconcileResponseIndexing(current.pending, runId);
+  }, [indexingQueryKey, queryClient, reconcileResponseIndexing]);
+
+  useEffect(() => {
+    if (indexingState.status !== 'delayed') return;
+    const retryTimer = window.setTimeout(retryResponseIndexing, 10_000);
+    return () => window.clearTimeout(retryTimer);
+  }, [indexingState.status, retryResponseIndexing]);
+
+  const optimisticResponse =
+    (indexingState.status !== 'reconciling' && indexingState.status !== 'delayed') || !indexingState.pending
+      ? undefined
+      : indexingState.pending.expectedResponse;
 
   return {
-    upvote,
-    downvote,
-    unvote,
+    submitResponse: responseMutation.mutate,
+    optimisticResponse,
+    isProcessingResponse:
+      responseMutation.isPending || indexingState.status === 'reconciling' || indexingState.status === 'delayed',
+    isResponseIndexingDelayed: indexingState.status === 'delayed',
     isConnected: !!personalSpaceId && isRegistered,
     personalSpaceId,
   };
diff --git a/apps/web/core/hooks/use-spaces-by-ids.ts b/apps/web/core/hooks/use-spaces-by-ids.ts
index becc5f18a2..d2e223691e 100644
--- a/apps/web/core/hooks/use-spaces-by-ids.ts
+++ b/apps/web/core/hooks/use-spaces-by-ids.ts
@@ -6,6 +6,7 @@ import { Effect } from 'effect';
 
 import { Space } from '~/core/io/dto/spaces';
 import { getSpaces } from '~/core/io/queries';
+import { spacesByIdsQueryKey } from '~/core/io/query-keys';
 
 type UseSpacesByIdsResult = {
   spaces: Space[];
@@ -15,12 +16,12 @@ type UseSpacesByIdsResult = {
 
 type UseSpacesByIdsData = Omit<UseSpacesByIdsResult, 'isLoading'>;
 
-export function useSpacesByIds(spaceIds: string[] = []): UseSpacesByIdsResult {
+export function useSpacesByIds(spaceIds: string[] = [], enabled = true): UseSpacesByIdsResult {
   const requestedIds = [...new Set(spaceIds.filter(Boolean))];
   const normalizedIds = [...requestedIds].sort();
 
   const { data, isLoading } = useQuery({
-    queryKey: ['spaces-by-ids', normalizedIds],
+    queryKey: spacesByIdsQueryKey(normalizedIds),
     queryFn: ({ signal }) => Effect.runPromise(getSpaces({ spaceIds: normalizedIds }, signal)),
     select: (fetchedSpaces): UseSpacesByIdsData => {
       const spacesById = new Map(fetchedSpaces.map(space => [space.id, space]));
@@ -31,7 +32,7 @@ export function useSpacesByIds(spaceIds: string[] = []): UseSpacesByIdsResult {
         spacesById,
       };
     },
-    enabled: normalizedIds.length > 0,
+    enabled: enabled && normalizedIds.length > 0,
   });
 
   return {
diff --git a/apps/web/core/io/entities-ordered-by-property-connection.test.ts b/apps/web/core/io/entities-ordered-by-property-connection.test.ts
index 236f264c61..e3f2cc1d5d 100644
--- a/apps/web/core/io/entities-ordered-by-property-connection.test.ts
+++ b/apps/web/core/io/entities-ordered-by-property-connection.test.ts
@@ -1,10 +1,9 @@
 import * as Effect from 'effect/Effect';
 import { type Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { SortOrder } from '~/core/gql/graphql';
-
 import { graphql } from './graphql-client';
 import { getEntitiesOrderedByPropertyConnection } from './queries';
+import { SortOrder } from './sort-order';
 
 vi.mock('./graphql-client', () => ({
   graphql: vi.fn(),
diff --git a/apps/web/core/io/queries.ts b/apps/web/core/io/queries.ts
index f110fff741..5ae9c1617d 100644
--- a/apps/web/core/io/queries.ts
+++ b/apps/web/core/io/queries.ts
@@ -15,11 +15,18 @@ import {
   type EntityExistsQuery,
   type EntityFilter,
   type EntitySpacesBatchQuery,
-  SortOrder,
   UserHasEntityVoteDocument,
+  type UserVoteFilter,
   type UuidFilter,
 } from '~/core/gql/graphql';
 import { RANKING_BLOCK_TYPE_ID } from '~/core/ranking-block-ids';
+import {
+  type ActiveResponseDirection,
+  type ResponseKind,
+  type ResponseObjectType,
+  decodeActiveResponseDirection,
+  entityResponseQueryVariables,
+} from '~/core/responses/entity-response';
 import { Entity, SearchResult } from '~/core/types';
 import { spacesFromRoutingProjections } from '~/core/utils/entity/entities';
 import { sortSpaceIdsByRank } from '~/core/utils/space/space-ranking';
@@ -35,6 +42,7 @@ import { Space } from './dto/spaces';
 import { entitiesOrderedByPropertyConnectionDocument } from './entities-ordered-by-property-connection-document';
 import { graphql } from './graphql-client';
 import {
+  claimResponseSummariesQuery,
   entitiesBatchQuery,
   entitiesPageQuery,
   entityBacklinksQuery,
@@ -42,11 +50,11 @@ import {
   entityPageQuery,
   entityQuery,
   entityRelationsPageQuery,
+  entityRespondersQuery,
+  entityResponseCountsQuery,
   entitySpacesBatchQuery,
   entityTiebreakerBatchQuery,
   entityTypesQuery,
-  entityVoteCountQuery,
-  entityVotersQuery,
   importNameValuesQuery,
   isEditorOfSpaceQuery,
   isMemberOfSpaceQuery,
@@ -62,9 +70,10 @@ import {
   spaceQuery,
   spacesQuery,
   spacesWhereMemberQuery,
-  userEntityVoteQuery,
+  userEntityResponseQuery,
 } from './query-fragments';
 import { restFetch } from './rest';
+import { type SortOrder } from './sort-order';
 import { extractSingleSpaceIdFromFilter, extractSpaceIdsFromFilter, removeSpaceIdsFromFilter } from './space-filter';
 import { extractSingleTypeIdFromFilter, extractTypeIdsFromFilter, removeTypeIdsFromFilter } from './type-filter';
 
@@ -1207,38 +1216,44 @@ export function getProperties(ids: string[], signal?: AbortController['signal'])
   });
 }
 
-export function getEntityVoteCount(
+export function getEntityResponseCounts(
   entityId: string,
-  objectType: 0 | 1 = 0, // objectType: 0 = Entity, 1 = Relation
+  spaceId: string,
+  responseKind: ResponseKind,
+  objectType: ResponseObjectType = 0, // objectType: 0 = Entity, 1 = Relation
   signal?: AbortController['signal']
 ) {
   return graphql({
-    query: entityVoteCountQuery,
+    query: entityResponseCountsQuery,
     decoder: data => {
-      const nodes = data.votesCountsConnection?.nodes;
-      if (!nodes || nodes.length === 0) return null;
-      const upvotes = nodes.reduce((sum: number, n: { upvotes: string }) => sum + Number(n.upvotes), 0);
-      const downvotes = nodes.reduce((sum: number, n: { downvotes: string }) => sum + Number(n.downvotes), 0);
-      return { upvotes, downvotes };
+      const counts = data.votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind;
+      if (!counts) return null;
+      return { positive: Number(counts.positive), negative: Number(counts.negative) };
     },
-    variables: { objectId: entityId, objectType },
+    variables: entityResponseQueryVariables(entityId, spaceId, objectType, responseKind),
     signal,
   });
 }
 
-export function getUserEntityVote(
+export function getUserEntityResponse(
   userId: string,
   entityId: string,
   spaceId: string,
-  objectType: 0 | 1 = 0,
+  responseKind: ResponseKind,
+  objectType: ResponseObjectType = 0,
   signal?: AbortController['signal']
 ) {
   return graphql({
-    query: userEntityVoteQuery,
+    query: userEntityResponseQuery,
     decoder: data => {
-      return data.userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId?.voteType ?? null;
+      return decodeActiveResponseDirection(
+        data.userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind?.voteType
+      );
+    },
+    variables: {
+      userId,
+      ...entityResponseQueryVariables(entityId, spaceId, objectType, responseKind),
     },
-    variables: { userId, objectId: entityId, objectType, spaceId },
     signal,
   });
 }
@@ -1252,20 +1267,51 @@ export function getUserHasEntityVote(userId: string, signal?: AbortController['s
   });
 }
 
-export type EntityVoter = { userId: string; voteType: number };
+export type EntityResponder = { userId: string; direction: ActiveResponseDirection };
 
-export function getEntityVoters(
+export type ClaimResponseSummaryRow = {
+  userId: string;
+  objectId: string;
+  voteType: number;
+  voteKind: number;
+};
+
+export function getClaimResponseSummaryPage(
+  filter: UserVoteFilter,
+  first: number,
+  offset: number,
+  signal?: AbortController['signal']
+) {
+  return graphql({
+    query: claimResponseSummariesQuery,
+    decoder: data =>
+      (data.userVotes ?? []).map((vote): ClaimResponseSummaryRow => ({
+        userId: String(vote.userId),
+        objectId: String(vote.objectId),
+        voteType: vote.voteType,
+        voteKind: vote.voteKind,
+      })),
+    variables: { filter, first, offset },
+    signal,
+  });
+}
+
+export function getEntityResponders(
   entityId: string,
   spaceId: string,
-  objectType: 0 | 1 = 0,
+  responseKind: ResponseKind,
+  objectType: ResponseObjectType = 0,
   signal?: AbortController['signal']
 ) {
   return graphql({
-    query: entityVotersQuery,
+    query: entityRespondersQuery,
     decoder: data => {
-      return (data.userVotes ?? []) as EntityVoter[];
+      return (data.userVotes ?? []).flatMap(vote => {
+        const direction = decodeActiveResponseDirection(vote.voteType);
+        return direction ? [{ userId: String(vote.userId), direction }] : [];
+      });
     },
-    variables: { objectId: entityId, objectType, spaceId },
+    variables: entityResponseQueryVariables(entityId, spaceId, objectType, responseKind),
     signal,
   });
 }
diff --git a/apps/web/core/io/query-fragments.response.test.ts b/apps/web/core/io/query-fragments.response.test.ts
new file mode 100644
index 0000000000..826ce2c236
--- /dev/null
+++ b/apps/web/core/io/query-fragments.response.test.ts
@@ -0,0 +1,51 @@
+import { print } from 'graphql';
+import { describe, expect, it } from 'vitest';
+
+import {
+  claimResponseSummariesQuery,
+  entityRespondersQuery,
+  entityResponseCountsQuery,
+  userEntityResponseQuery,
+} from './query-fragments';
+
+describe('entity response query fragments', () => {
+  it('reads counts for one exact object, space, and vote kind', () => {
+    const query = print(entityResponseCountsQuery);
+
+    expect(query).toContain('votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind');
+    expect(query).toContain('spaceId: $spaceId');
+    expect(query).toContain('voteKind: $voteKind');
+    expect(query).toContain('positive');
+    expect(query).toContain('negative');
+  });
+
+  it('reads the current user response for one exact kind', () => {
+    const query = print(userEntityResponseQuery);
+
+    expect(query).toContain('userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind');
+    expect(query).toContain('spaceId: $spaceId');
+    expect(query).toContain('voteKind: $voteKind');
+  });
+
+  it('scopes responders by space and vote kind', () => {
+    const query = print(entityRespondersQuery);
+
+    expect(query).toContain('condition:');
+    expect(query).toContain('spaceId: $spaceId');
+    expect(query).toContain('voteKind: $voteKind');
+  });
+
+  it('reads one deterministic page of response summaries for exact claim and kind filters', () => {
+    const query = print(claimResponseSummariesQuery);
+
+    expect(query).toContain('query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!)');
+    expect(query).toContain('filter: $filter');
+    expect(query).toContain('first: $first');
+    expect(query).toContain('offset: $offset');
+    expect(query).toContain('orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]');
+    expect(query).toContain('userId');
+    expect(query).toContain('objectId');
+    expect(query).toContain('voteType');
+    expect(query).toContain('voteKind');
+  });
+});
diff --git a/apps/web/core/io/query-fragments.tsx b/apps/web/core/io/query-fragments.tsx
index 70cb46a400..9d1eb270bd 100644
--- a/apps/web/core/io/query-fragments.tsx
+++ b/apps/web/core/io/query-fragments.tsx
@@ -753,36 +753,51 @@ export const relationEntityQuery = graphql(/* GraphQL */ `
   }
 `);
 
-export const entityVoteCountQuery = graphql(/* GraphQL */ `
-  query EntityVoteCount($objectId: UUID!, $objectType: Int!) {
-    votesCountsConnection(condition: { objectId: $objectId, objectType: $objectType }) {
-      nodes {
-        spaceId
-        upvotes
-        downvotes
-      }
+export const entityResponseCountsQuery = graphql(/* GraphQL */ `
+  query EntityResponseCounts($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {
+    votesCountByObjectIdAndObjectTypeAndSpaceIdAndVoteKind(
+      objectId: $objectId
+      objectType: $objectType
+      spaceId: $spaceId
+      voteKind: $voteKind
+    ) {
+      positive
+      negative
+      voteKind
     }
   }
 `);
 
-export const userEntityVoteQuery = graphql(/* GraphQL */ `
-  query UserEntityVote($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {
-    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceId(
+export const userEntityResponseQuery = graphql(/* GraphQL */ `
+  query UserEntityResponse($userId: UUID!, $objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {
+    userVoteByUserIdAndObjectIdAndObjectTypeAndSpaceIdAndVoteKind(
       userId: $userId
       objectId: $objectId
       objectType: $objectType
       spaceId: $spaceId
+      voteKind: $voteKind
     ) {
       voteType
     }
   }
 `);
 
-export const entityVotersQuery = graphql(/* GraphQL */ `
-  query EntityVoters($objectId: UUID!, $objectType: Int!, $spaceId: UUID!) {
-    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId }) {
+export const entityRespondersQuery = graphql(/* GraphQL */ `
+  query EntityResponders($objectId: UUID!, $objectType: Int!, $spaceId: UUID!, $voteKind: Int!) {
+    userVotes(condition: { objectId: $objectId, objectType: $objectType, spaceId: $spaceId, voteKind: $voteKind }) {
+      userId
+      voteType
+    }
+  }
+`);
+
+export const claimResponseSummariesQuery = graphql(/* GraphQL */ `
+  query ClaimResponseSummaries($filter: UserVoteFilter!, $first: Int!, $offset: Int!) {
+    userVotes(filter: $filter, first: $first, offset: $offset, orderBy: [OBJECT_ID_ASC, VOTE_KIND_ASC, USER_ID_ASC]) {
       userId
+      objectId
       voteType
+      voteKind
     }
   }
 `);
diff --git a/apps/web/core/io/query-keys.ts b/apps/web/core/io/query-keys.ts
new file mode 100644
index 0000000000..d5235f272d
--- /dev/null
+++ b/apps/web/core/io/query-keys.ts
@@ -0,0 +1,11 @@
+function normalizeSpaceIds(spaceIds: string[]) {
+  return [...new Set(spaceIds.filter(Boolean))].sort();
+}
+
+export function profilesBySpaceIdsQueryKey(spaceIds: string[]) {
+  return ['profiles-by-space-ids', normalizeSpaceIds(spaceIds)] as const;
+}
+
+export function spacesByIdsQueryKey(spaceIds: string[]) {
+  return ['spaces-by-ids', normalizeSpaceIds(spaceIds)] as const;
+}
diff --git a/apps/web/core/io/sort-order.ts b/apps/web/core/io/sort-order.ts
new file mode 100644
index 0000000000..f29679877a
--- /dev/null
+++ b/apps/web/core/io/sort-order.ts
@@ -0,0 +1,6 @@
+export const SortOrder = {
+  Asc: 'ASC',
+  Desc: 'DESC',
+} as const;
+
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
diff --git a/apps/web/core/responses/claim-response-summaries.test.ts b/apps/web/core/responses/claim-response-summaries.test.ts
new file mode 100644
index 0000000000..9502e3f1c9
--- /dev/null
+++ b/apps/web/core/responses/claim-response-summaries.test.ts
@@ -0,0 +1,328 @@
+import { QueryClient } from '@tanstack/react-query';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import type { Space } from '~/core/io/dto/spaces';
+import { profilesBySpaceIdsQueryKey, spacesByIdsQueryKey } from '~/core/io/query-keys';
+import type { Profile } from '~/core/types';
+
+import {
+  CLAIM_RESPONSE_SUMMARY_PAGE_SIZE,
+  buildClaimResponseSummaryFilter,
+  fetchClaimResponseSummaries,
+  groupClaimResponseSummaryRows,
+  loadClaimResponderMetadataCaches,
+  loadClaimResponseSummaryCaches,
+  normalizeClaimResponseTargets,
+} from './claim-response-summaries';
+import {
+  entityResponderProfilesQueryKey,
+  entityRespondersQueryKey,
+  entityResponseCountsQueryKey,
+  userEntityResponseQueryKey,
+} from './entity-response';
+
+const targets = [
+  { entityId: 'claim-veracity', responseKind: 'veracity' as const },
+  { entityId: 'claim-stance', responseKind: 'stance' as const },
+];
+
+describe('claim response summaries', () => {
+  it('normalizes duplicate claim-kind pairs deterministically', () => {
+    expect(normalizeClaimResponseTargets([targets[0], targets[1], targets[0]])).toEqual([
+      { entityId: 'claim-stance', responseKind: 'stance' },
+      { entityId: 'claim-veracity', responseKind: 'veracity' },
+    ]);
+  });
+
+  it('builds an exact-space entity filter with one exact branch per active vote kind', () => {
+    expect(buildClaimResponseSummaryFilter('space-1', targets)).toEqual({
+      spaceId: { is: 'space-1' },
+      objectType: { is: 0 },
+      voteType: { in: [0, 1] },
+      or: [
+        { objectId: { is: 'claim-stance' }, voteKind: { is: 1 } },
+        { objectId: { is: 'claim-veracity' }, voteKind: { is: 2 } },
+      ],
+    });
+  });
+
+  it('groups active positive and negative rows and ignores cleared or inactive-kind rows', () => {
+    const summaries = groupClaimResponseSummaryRows(
+      targets,
+      [
+        row('claim-stance', 1, 'viewer', 0),
+        row('claim-stance', 1, 'negative-user', 1),
+        row('claim-stance', 1, 'cleared-user', 2),
+        row('claim-stance', 2, 'wrong-kind', 0),
+        row('claim-veracity', 2, 'verifier', 0),
+        row('another-claim', 1, 'wrong-claim', 0),
+      ],
+      'viewer'
+    );
+
+    expect(summaries.get('claim-stance:stance')).toEqual({
+      counts: { positive: 1, negative: 1 },
+      viewerResponse: 'positive',
+      responders: [
+        { userId: 'viewer', direction: 'positive' },
+        { userId: 'negative-user', direction: 'negative' },
+      ],
+    });
+    expect(summaries.get('claim-veracity:veracity')).toEqual({
+      counts: { positive: 1, negative: 0 },
+      viewerResponse: null,
+      responders: [{ userId: 'verifier', direction: 'positive' }],
+    });
+  });
+
+  it('does not assign a viewer response for anonymous requests', () => {
+    const summaries = groupClaimResponseSummaryRows(
+      [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      [row('claim-stance', 1, 'user-1', 1)],
+      null
+    );
+
+    expect(summaries.get('claim-stance:stance')?.viewerResponse).toBeNull();
+  });
+
+  it('paginates in deterministic 1,000-row pages and deduplicates rows repeated across pages', async () => {
+    const firstPage = Array.from({ length: CLAIM_RESPONSE_SUMMARY_PAGE_SIZE }, (_, index) =>
+      row('claim-stance', 1, `user-${index}`, index % 2)
+    );
+    const duplicate = firstPage.at(-1)!;
+    const fetchPage = vi
+      .fn()
+      .mockResolvedValueOnce(firstPage)
+      .mockResolvedValueOnce([duplicate, row('claim-stance', 1, 'user-1000', 0)]);
+
+    const summaries = await fetchClaimResponseSummaries({
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      personalSpaceId: 'user-1000',
+      fetchPage,
+    });
+
+    expect(fetchPage).toHaveBeenCalledTimes(2);
+    expect(fetchPage.mock.calls.map(call => call[0].offset)).toEqual([0, 1000]);
+    expect(fetchPage.mock.calls[0]?.[0]).toMatchObject({
+      first: 1000,
+      filter: {
+        spaceId: { is: 'space-1' },
+        objectType: { is: 0 },
+        or: [{ objectId: { is: 'claim-stance' }, voteKind: { is: 1 } }],
+      },
+    });
+    expect(summaries.get('claim-stance:stance')).toMatchObject({
+      counts: { positive: 501, negative: 500 },
+      viewerResponse: 'positive',
+    });
+    expect(summaries.get('claim-stance:stance')?.responders).toHaveLength(1001);
+  });
+
+  it('deduplicates avatar metadata in chunks and seeds every existing per-claim cache', async () => {
+    const queryClient = new QueryClient();
+    const responderIds = Array.from({ length: 205 }, (_, index) => `profile-${index}`);
+    const summary = {
+      counts: { positive: 103, negative: 102 },
+      viewerResponse: 'negative' as const,
+      responders: responderIds.map((userId, index) => ({
+        userId,
+        direction: index % 2 === 0 ? ('positive' as const) : ('negative' as const),
+      })),
+    };
+    const fetchSummaries = vi.fn().mockResolvedValue(new Map([['claim-stance:stance', summary]]));
+    const fetchProfiles = vi.fn(async (ids: string[]) =>
+      ids.map(id => ({ spaceId: id, address: `0x${id}` }) as Profile)
+    );
+    const fetchSpaces = vi.fn(async (ids: string[]) =>
+      ids.map(id => ({ id, entity: { id: `entity-${id}` } }) as Space)
+    );
+
+    const summaries = await loadClaimResponseSummaryCaches({
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      personalSpaceId: 'profile-1',
+      fetchSummaries,
+    });
+    await loadClaimResponderMetadataCaches({
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      summaries,
+      fetchProfiles,
+      fetchSpaces,
+    });
+
+    expect(fetchProfiles.mock.calls.map(call => call[0].length)).toEqual([100, 100, 5]);
+    expect(fetchSpaces.mock.calls.map(call => call[0].length)).toEqual([100, 100, 5]);
+    expect(queryClient.getQueryData(entityResponseCountsQueryKey('claim-stance', 'space-1', 0, 'stance'))).toEqual(
+      summary.counts
+    );
+    expect(
+      queryClient.getQueryData(userEntityResponseQueryKey('profile-1', 'claim-stance', 'space-1', 0, 'stance'))
+    ).toBe('negative');
+    expect(queryClient.getQueryData(entityRespondersQueryKey('claim-stance', 'space-1', 0, 'stance'))).toEqual(
+      summary.responders
+    );
+    expect(
+      queryClient.getQueryData([
+        ...entityResponderProfilesQueryKey('claim-stance', 'space-1', 0, 'stance'),
+        responderIds,
+      ])
+    ).toHaveLength(205);
+    expect(queryClient.getQueryData(profilesBySpaceIdsQueryKey(responderIds))).toBeInstanceOf(Map);
+    expect(queryClient.getQueryData(spacesByIdsQueryKey(responderIds))).toHaveLength(205);
+  });
+
+  it('keeps response caches usable when avatar metadata fails and reuses successful metadata on retry', async () => {
+    const queryClient = new QueryClient();
+    const fetchSummaries = vi.fn().mockResolvedValue(
+      new Map([
+        [
+          'claim-stance:stance',
+          {
+            counts: { positive: 1, negative: 0 },
+            viewerResponse: null,
+            responders: [{ userId: 'profile-1', direction: 'positive' }],
+          },
+        ],
+      ])
+    );
+    const fetchProfiles = vi.fn(async () => [{ spaceId: 'profile-1', address: '0x1' } as unknown as Profile]);
+    const fetchSpaces = vi
+      .fn<() => Promise<Space[]>>()
+      .mockRejectedValueOnce(new Error('space metadata unavailable'))
+      .mockResolvedValueOnce([{ id: 'profile-1', entity: { id: 'profile-1' } } as Space]);
+    const summaries = await loadClaimResponseSummaryCaches({
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' as const }],
+      personalSpaceId: null,
+      fetchSummaries,
+    });
+    const metadataArgs = {
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' as const }],
+      summaries,
+      fetchProfiles,
+      fetchSpaces,
+    };
+
+    await expect(loadClaimResponderMetadataCaches(metadataArgs)).rejects.toThrow('space metadata unavailable');
+    expect(queryClient.getQueryData(entityResponseCountsQueryKey('claim-stance', 'space-1', 0, 'stance'))).toEqual({
+      positive: 1,
+      negative: 0,
+    });
+    await expect(loadClaimResponderMetadataCaches(metadataArgs)).resolves.toBeUndefined();
+
+    expect(fetchSummaries).toHaveBeenCalledOnce();
+    expect(fetchProfiles).toHaveBeenCalledOnce();
+    expect(fetchSpaces).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not seed avatar caches after metadata enrichment is cancelled', async () => {
+    const queryClient = new QueryClient();
+    const controller = new AbortController();
+    const fetchSummaries = vi.fn().mockResolvedValue(
+      new Map([
+        [
+          'claim-stance:stance',
+          {
+            counts: { positive: 1, negative: 0 },
+            viewerResponse: 'positive' as const,
+            responders: [{ userId: 'profile-1', direction: 'positive' as const }],
+          },
+        ],
+      ])
+    );
+    const fetchProfiles = vi.fn(async () => {
+      controller.abort();
+      return [{ spaceId: 'profile-1', address: '0x1' } as unknown as Profile];
+    });
+
+    const summaries = await loadClaimResponseSummaryCaches({
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      personalSpaceId: 'profile-1',
+      fetchSummaries,
+    });
+
+    await expect(
+      loadClaimResponderMetadataCaches({
+        queryClient,
+        spaceId: 'space-1',
+        targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+        summaries,
+        signal: controller.signal,
+        fetchProfiles,
+        fetchSpaces: vi.fn(async () => [{ id: 'profile-1', entity: { id: 'profile-1' } } as Space]),
+      })
+    ).rejects.toBeDefined();
+
+    expect(queryClient.getQueryData(entityResponseCountsQueryKey('claim-stance', 'space-1', 0, 'stance'))).toEqual({
+      positive: 1,
+      negative: 0,
+    });
+    expect(
+      queryClient.getQueryData([
+        ...entityResponderProfilesQueryKey('claim-stance', 'space-1', 0, 'stance'),
+        ['profile-1'],
+      ])
+    ).toBeUndefined();
+  });
+
+  it('caps concurrent responder profile and space metadata requests', async () => {
+    const queryClient = new QueryClient();
+    const responderIds = Array.from({ length: 505 }, (_, index) => `profile-${index}`);
+    const summaries = new Map([
+      [
+        'claim-stance:stance',
+        {
+          counts: { positive: 505, negative: 0 },
+          viewerResponse: null,
+          responders: responderIds.map(userId => ({ userId, direction: 'positive' as const })),
+        },
+      ],
+    ]);
+    let activeProfiles = 0;
+    let activeSpaces = 0;
+    let maxProfiles = 0;
+    let maxSpaces = 0;
+    const fetchProfiles = vi.fn(async (ids: string[]) => {
+      activeProfiles += 1;
+      maxProfiles = Math.max(maxProfiles, activeProfiles);
+      await Promise.resolve();
+      activeProfiles -= 1;
+      return ids.map(id => ({ spaceId: id, address: `0x${id}` }) as Profile);
+    });
+    const fetchSpaces = vi.fn(async (ids: string[]) => {
+      activeSpaces += 1;
+      maxSpaces = Math.max(maxSpaces, activeSpaces);
+      await Promise.resolve();
+      activeSpaces -= 1;
+      return ids.map(id => ({ id, entity: { id } }) as Space);
+    });
+
+    await loadClaimResponderMetadataCaches({
+      queryClient,
+      spaceId: 'space-1',
+      targets: [{ entityId: 'claim-stance', responseKind: 'stance' }],
+      summaries,
+      fetchProfiles,
+      fetchSpaces,
+    });
+
+    expect(fetchProfiles).toHaveBeenCalledTimes(6);
+    expect(fetchSpaces).toHaveBeenCalledTimes(6);
+    expect(maxProfiles).toBeLessThanOrEqual(4);
+    expect(maxSpaces).toBeLessThanOrEqual(4);
+  });
+});
+
+function row(objectId: string, voteKind: number, userId: string, voteType: number) {
+  return { objectId, voteKind, userId, voteType };
+}
diff --git a/apps/web/core/responses/claim-response-summaries.ts b/apps/web/core/responses/claim-response-summaries.ts
new file mode 100644
index 0000000000..b10cc588b3
--- /dev/null
+++ b/apps/web/core/responses/claim-response-summaries.ts
@@ -0,0 +1,309 @@
+import type { QueryClient } from '@tanstack/react-query';
+
+import { Effect } from 'effect';
+
+import type { UserVoteFilter } from '~/core/gql/graphql';
+import type { Space } from '~/core/io/dto/spaces';
+import {
+  type ClaimResponseSummaryRow,
+  type EntityResponder,
+  getClaimResponseSummaryPage,
+  getSpaces,
+} from '~/core/io/queries';
+import { profilesBySpaceIdsQueryKey, spacesByIdsQueryKey } from '~/core/io/query-keys';
+import { fetchProfilesBySpaceIds } from '~/core/io/subgraph/fetch-profile';
+import type { Profile } from '~/core/types';
+import { mapWithConcurrency } from '~/core/utils/map-with-concurrency';
+
+import { claimResponseTargetKey } from './claim-response-summary-query-keys';
+import {
+  type ActiveResponseDirection,
+  type ResponseKind,
+  decodeActiveResponseDirection,
+  entityResponderProfilesQueryKey,
+  entityRespondersQueryKey,
+  entityResponseCountsQueryKey,
+  responseKindToVoteKind,
+  userEntityResponseQueryKey,
+} from './entity-response';
+
+export { claimResponseSummariesQueryKeyPrefix, claimResponseTargetKey } from './claim-response-summary-query-keys';
+
+export const CLAIM_RESPONSE_SUMMARY_PAGE_SIZE = 1_000;
+const RESPONDER_METADATA_CHUNK_SIZE = 100;
+const RESPONDER_METADATA_CONCURRENCY = 4;
+
+export type ClaimResponseTarget = {
+  entityId: string;
+  responseKind: ResponseKind;
+};
+
+export type ClaimResponseSummary = {
+  counts: { positive: number; negative: number };
+  viewerResponse: ActiveResponseDirection | null;
+  responders: EntityResponder[];
+};
+
+type FetchSummaryPageArgs = {
+  filter: UserVoteFilter;
+  first: number;
+  offset: number;
+  signal?: AbortSignal;
+};
+
+type FetchSummaryPage = (args: FetchSummaryPageArgs) => Promise<ClaimResponseSummaryRow[]>;
+type FetchSummaries = typeof fetchClaimResponseSummaries;
+type FetchProfiles = (spaceIds: string[]) => Promise<Profile[]>;
+type FetchSpaces = (spaceIds: string[], signal?: AbortSignal) => Promise<Space[]>;
+
+export function normalizeClaimResponseTargets(targets: ClaimResponseTarget[]) {
+  const byKey = new Map(targets.map(target => [claimResponseTargetKey(target), target]));
+  return [...byKey.values()].sort((left, right) =>
+    claimResponseTargetKey(left).localeCompare(claimResponseTargetKey(right))
+  );
+}
+
+export function buildClaimResponseSummaryFilter(spaceId: string, targets: ClaimResponseTarget[]): UserVoteFilter {
+  return {
+    spaceId: { is: spaceId },
+    objectType: { is: 0 },
+    voteType: { in: [0, 1] },
+    or: normalizeClaimResponseTargets(targets).map(target => ({
+      objectId: { is: target.entityId },
+      voteKind: { is: responseKindToVoteKind(target.responseKind) },
+    })),
+  };
+}
+
+export function groupClaimResponseSummaryRows(
+  targets: ClaimResponseTarget[],
+  rows: ClaimResponseSummaryRow[],
+  personalSpaceId: string | null
+): Map<string, ClaimResponseSummary> {
+  const normalizedTargets = normalizeClaimResponseTargets(targets);
+  const targetByObjectAndKind = new Map(
+    normalizedTargets.map(target => [`${target.entityId}:${responseKindToVoteKind(target.responseKind)}`, target])
+  );
+  const activeRows = new Map<string, { target: ClaimResponseTarget; row: ClaimResponseSummaryRow }>();
+
+  for (const row of rows) {
+    const target = targetByObjectAndKind.get(`${row.objectId}:${row.voteKind}`);
+    const direction = decodeActiveResponseDirection(row.voteType);
+    if (!target || !direction) continue;
+    activeRows.set(`${claimResponseTargetKey(target)}:${row.userId}`, { target, row });
+  }
+
+  const summaries = new Map<string, ClaimResponseSummary>(
+    normalizedTargets.map(target => [
+      claimResponseTargetKey(target),
+      { counts: { positive: 0, negative: 0 }, viewerResponse: null, responders: [] },
+    ])
+  );
+
+  for (const { target, row } of activeRows.values()) {
+    const direction = decodeActiveResponseDirection(row.voteType);
+    if (!direction) continue;
+    const summary = summaries.get(claimResponseTargetKey(target));
+    if (!summary) continue;
+    summary.counts[direction] += 1;
+    summary.responders.push({ userId: row.userId, direction });
+    if (personalSpaceId && row.userId === personalSpaceId) summary.viewerResponse = direction;
+  }
+
+  return summaries;
+}
+
+export async function fetchClaimResponseSummaries({
+  spaceId,
+  targets,
+  personalSpaceId,
+  signal,
+  fetchPage = defaultFetchPage,
+}: {
+  spaceId: string;
+  targets: ClaimResponseTarget[];
+  personalSpaceId: string | null;
+  signal?: AbortSignal;
+  fetchPage?: FetchSummaryPage;
+}) {
+  const normalizedTargets = normalizeClaimResponseTargets(targets);
+  if (normalizedTargets.length === 0) return new Map<string, ClaimResponseSummary>();
+
+  const filter = buildClaimResponseSummaryFilter(spaceId, normalizedTargets);
+  const rows: ClaimResponseSummaryRow[] = [];
+  let offset = 0;
+
+  while (true) {
+    const page = await fetchPage({ filter, first: CLAIM_RESPONSE_SUMMARY_PAGE_SIZE, offset, signal });
+    rows.push(...page);
+    if (page.length < CLAIM_RESPONSE_SUMMARY_PAGE_SIZE) break;
+    offset += CLAIM_RESPONSE_SUMMARY_PAGE_SIZE;
+  }
+
+  return groupClaimResponseSummaryRows(normalizedTargets, rows, personalSpaceId);
+}
+
+function defaultFetchPage({ filter, first, offset, signal }: FetchSummaryPageArgs) {
+  return Effect.runPromise(getClaimResponseSummaryPage(filter, first, offset, signal));
+}
+
+export async function loadClaimResponseSummaryCaches({
+  queryClient,
+  spaceId,
+  targets,
+  personalSpaceId,
+  signal,
+  fetchSummaries = fetchClaimResponseSummaries,
+  forceResponseRefresh = false,
+}: {
+  queryClient: QueryClient;
+  spaceId: string;
+  targets: ClaimResponseTarget[];
+  personalSpaceId: string | null;
+  signal?: AbortSignal;
+  fetchSummaries?: FetchSummaries;
+  forceResponseRefresh?: boolean;
+}) {
+  const normalizedTargets = normalizeClaimResponseTargets(targets);
+  const summaryQueryKey = [
+    'claim-response-summary-data',
+    personalSpaceId,
+    spaceId,
+    normalizedTargets.map(claimResponseTargetKey),
+  ] as const;
+  const summaries = await queryClient.fetchQuery({
+    queryKey: summaryQueryKey,
+    queryFn: () => fetchSummaries({ spaceId, targets: normalizedTargets, personalSpaceId, signal }),
+    staleTime: forceResponseRefresh ? 0 : 30_000,
+    retry: false,
+  });
+  signal?.throwIfAborted();
+
+  for (const target of normalizedTargets) {
+    const summary = summaries.get(claimResponseTargetKey(target)) ?? emptySummary();
+
+    queryClient.setQueryData(
+      entityResponseCountsQueryKey(target.entityId, spaceId, 0, target.responseKind),
+      summary.counts
+    );
+    queryClient.setQueryData(
+      entityRespondersQueryKey(target.entityId, spaceId, 0, target.responseKind),
+      summary.responders
+    );
+    if (personalSpaceId) {
+      queryClient.setQueryData(
+        userEntityResponseQueryKey(personalSpaceId, target.entityId, spaceId, 0, target.responseKind),
+        summary.viewerResponse
+      );
+    }
+  }
+
+  return summaries;
+}
+
+export function claimResponseSummaryResponderSpaceIds(summaries: Map<string, ClaimResponseSummary>) {
+  return [
+    ...new Set(
+      [...summaries.values()].flatMap(summary => summary.responders.map(responder => responder.userId)).filter(Boolean)
+    ),
+  ].sort();
+}
+
+export async function loadClaimResponderMetadataCaches({
+  queryClient,
+  spaceId,
+  targets,
+  summaries,
+  signal,
+  fetchProfiles = defaultFetchProfiles,
+  fetchSpaces = defaultFetchSpaces,
+}: {
+  queryClient: QueryClient;
+  spaceId: string;
+  targets: ClaimResponseTarget[];
+  summaries: Map<string, ClaimResponseSummary>;
+  signal?: AbortSignal;
+  fetchProfiles?: FetchProfiles;
+  fetchSpaces?: FetchSpaces;
+}) {
+  const normalizedTargets = normalizeClaimResponseTargets(targets);
+  const responderSpaceIds = claimResponseSummaryResponderSpaceIds(summaries);
+  if (responderSpaceIds.length === 0) return;
+
+  const [profilesBySpaceId, responderSpaces] = await Promise.all([
+    queryClient.fetchQuery({
+      queryKey: profilesBySpaceIdsQueryKey(responderSpaceIds),
+      queryFn: async () => {
+        const profileChunks = await mapWithConcurrency(
+          chunk(responderSpaceIds, RESPONDER_METADATA_CHUNK_SIZE),
+          RESPONDER_METADATA_CONCURRENCY,
+          ids => fetchProfiles(ids)
+        );
+        return new Map(profileChunks.flat().map(profile => [profile.spaceId, profile]));
+      },
+      staleTime: 60_000,
+      retry: false,
+    }),
+    queryClient.fetchQuery({
+      queryKey: spacesByIdsQueryKey(responderSpaceIds),
+      queryFn: async () => {
+        const spaceChunks = await mapWithConcurrency(
+          chunk(responderSpaceIds, RESPONDER_METADATA_CHUNK_SIZE),
+          RESPONDER_METADATA_CONCURRENCY,
+          ids => fetchSpaces(ids, signal)
+        );
+        return spaceChunks.flat();
+      },
+      staleTime: 60_000,
+      retry: false,
+    }),
+  ]);
+  const spacesById = new Map(responderSpaces.map(space => [space.id, space]));
+
+  signal?.throwIfAborted();
+
+  for (const target of normalizedTargets) {
+    const summary = summaries.get(claimResponseTargetKey(target)) ?? emptySummary();
+    const responderIds = summary.responders.map(responder => responder.userId);
+    const responderProfiles = responderIds.flatMap(id => {
+      const profile = profilesBySpaceId.get(id);
+      return profile ? [profile] : [];
+    });
+
+    if (responderIds.length > 0) {
+      queryClient.setQueryData(
+        [...entityResponderProfilesQueryKey(target.entityId, spaceId, 0, target.responseKind), responderIds],
+        responderProfiles
+      );
+      queryClient.setQueryData(
+        profilesBySpaceIdsQueryKey(responderIds),
+        new Map(responderProfiles.map(profile => [profile.spaceId, profile]))
+      );
+      queryClient.setQueryData(
+        spacesByIdsQueryKey(responderIds),
+        [...responderIds].sort().flatMap(id => {
+          const space = spacesById.get(id);
+          return space ? [space] : [];
+        })
+      );
+    }
+  }
+}
+
+function emptySummary(): ClaimResponseSummary {
+  return { counts: { positive: 0, negative: 0 }, viewerResponse: null, responders: [] };
+}
+
+function chunk<T>(items: T[], size: number) {
+  const chunks: T[][] = [];
+  for (let start = 0; start < items.length; start += size) chunks.push(items.slice(start, start + size));
+  return chunks;
+}
+
+function defaultFetchProfiles(spaceIds: string[]) {
+  return Effect.runPromise(fetchProfilesBySpaceIds(spaceIds));
+}
+
+function defaultFetchSpaces(spaceIds: string[], signal?: AbortSignal) {
+  return Effect.runPromise(getSpaces({ spaceIds, limit: spaceIds.length }, signal));
+}
diff --git a/apps/web/core/responses/claim-response-summary-query-keys.ts b/apps/web/core/responses/claim-response-summary-query-keys.ts
new file mode 100644
index 0000000000..71636fe2fa
--- /dev/null
+++ b/apps/web/core/responses/claim-response-summary-query-keys.ts
@@ -0,0 +1,25 @@
+import type { ResponseKind } from './entity-response';
+
+const CLAIM_RESPONSE_SUMMARY_QUERY_ROOTS = new Set(['claim-response-summaries', 'claim-response-summary-data']);
+
+export function claimResponseTargetKey(target: { entityId: string; responseKind: ResponseKind }) {
+  return `${target.entityId}:${target.responseKind}`;
+}
+
+export function claimResponseSummariesQueryKeyPrefix(personalSpaceId: string | null, spaceId: string) {
+  return ['claim-response-summaries', personalSpaceId, spaceId] as const;
+}
+
+export function isClaimResponseSummaryQueryKey(
+  queryKey: readonly unknown[],
+  filters: { spaceId?: string; targetKeys?: ReadonlySet<string> } = {}
+) {
+  const [root, , spaceId, targetKeys] = queryKey;
+  if (typeof root !== 'string' || !CLAIM_RESPONSE_SUMMARY_QUERY_ROOTS.has(root)) return false;
+  if (filters.spaceId !== undefined && spaceId !== filters.spaceId) return false;
+  if (!filters.targetKeys) return true;
+  return (
+    Array.isArray(targetKeys) &&
+    targetKeys.some(target => typeof target === 'string' && filters.targetKeys?.has(target))
+  );
+}
diff --git a/apps/web/core/responses/entity-response.test.ts b/apps/web/core/responses/entity-response.test.ts
new file mode 100644
index 0000000000..3f341877a9
--- /dev/null
+++ b/apps/web/core/responses/entity-response.test.ts
@@ -0,0 +1,254 @@
+import { SystemIds } from '@geoprotocol/geo-sdk/lite';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID } from '~/core/claims/ontology';
+
+import { getChecked } from '~/design-system/checkbox';
+
+import {
+  ENTITY_RESPONSE_COPY,
+  decodeActiveResponseDirection,
+  entityRespondersQueryKey,
+  entityResponseCountsQueryKey,
+  entityResponseIndexingQueryKey,
+  entityResponseQueryVariables,
+  getEntityResponseKind,
+  getResponseActionMethod,
+  hasUnpublishedClaimResponseKindEdit,
+  responseKindToVoteKind,
+  userEntityResponseQueryKey,
+  waitForIndexedEntityResponse,
+} from './entity-response';
+
+const SPACE_ID = '1234567890abcdef1234567890abcdef';
+const OTHER_SPACE_ID = 'abcdef1234567890abcdef1234567890';
+
+describe('entity response semantics', () => {
+  it.each([
+    [{ isClaim: false, isFactual: false }, 'curation'],
+    [{ isClaim: false, isFactual: true }, 'curation'],
+    [{ isClaim: true, isFactual: false }, 'stance'],
+    [{ isClaim: true, isFactual: true }, 'veracity'],
+  ] as const)('selects the active response kind for %o', (input, expected) => {
+    expect(getEntityResponseKind(input)).toBe(expected);
+  });
+
+  it.each([
+    ['1', 'veracity'],
+    ['0', 'stance'],
+    [undefined, 'stance'],
+    ['true', 'stance'],
+    ['yes', 'stance'],
+    ['malformed', 'stance'],
+  ] as const)('uses canonical checked semantics for factual value %s', (factualValue, expected) => {
+    expect(getEntityResponseKind({ isClaim: true, isFactual: getChecked(factualValue) === true })).toBe(expected);
+  });
+
+  it.each([
+    ['curation', 0],
+    ['stance', 1],
+    ['veracity', 2],
+  ] as const)('maps %s to backend voteKind %i', (kind, expected) => {
+    expect(responseKindToVoteKind(kind)).toBe(expected);
+  });
+
+  it.each([
+    ['curation', 'positive', 'upvote'],
+    ['curation', 'negative', 'downvote'],
+    ['curation', 'clear', 'unvote'],
+    ['stance', 'positive', 'agree'],
+    ['stance', 'negative', 'disagree'],
+    ['stance', 'clear', 'unagree'],
+    ['veracity', 'positive', 'verify'],
+    ['veracity', 'negative', 'dispute'],
+    ['veracity', 'clear', 'unverify'],
+  ] as const)('routes %s/%s to geo.responses.%s', (kind, direction, expected) => {
+    expect(getResponseActionMethod(kind, direction)).toBe(expected);
+  });
+
+  it.each([
+    ['curation', 'Upvote', 'Downvote', 'No votes yet'],
+    ['stance', 'Agree', 'Disagree', 'No stances yet'],
+    ['veracity', 'Verify', 'Dispute', 'No veracity responses yet'],
+  ] as const)('uses semantic %s response copy', (kind, positive, negative, empty) => {
+    expect(ENTITY_RESPONSE_COPY[kind]).toMatchObject({
+      positiveAction: positive,
+      negativeAction: negative,
+      empty,
+    });
+  });
+
+  it.each([
+    [0, 'positive'],
+    [1, 'negative'],
+    [2, null],
+    [null, null],
+    [undefined, null],
+    [9, null],
+  ] as const)('normalizes backend voteType %s to %s', (voteType, expected) => {
+    expect(decodeActiveResponseDirection(voteType)).toBe(expected);
+  });
+
+  it('blocks responses while an exact-space factual edit is still unpublished', () => {
+    const entity = {
+      relations: [],
+      values: [
+        {
+          spaceId: SPACE_ID,
+          property: { id: CLAIM_IS_FACTUAL_PROPERTY_ID },
+          isLocal: true,
+          hasBeenPublished: false,
+        },
+      ],
+    } as unknown as NonNullable<Parameters<typeof hasUnpublishedClaimResponseKindEdit>[0]>;
+
+    expect(hasUnpublishedClaimResponseKindEdit(entity, SPACE_ID)).toBe(true);
+    expect(hasUnpublishedClaimResponseKindEdit(entity, OTHER_SPACE_ID)).toBe(false);
+
+    entity.values[0]!.hasBeenPublished = true;
+    expect(hasUnpublishedClaimResponseKindEdit(entity, SPACE_ID)).toBe(false);
+  });
+
+  it('blocks responses for unpublished response-kind tombstones', () => {
+    const entity = {
+      values: [],
+      relations: [
+        {
+          spaceId: SPACE_ID,
+          type: { id: SystemIds.TYPES_PROPERTY },
+          toEntity: { id: CLAIM_TYPE_ID },
+          isDeleted: true,
+          isLocal: true,
+          hasBeenPublished: false,
+        },
+      ],
+    } as unknown as NonNullable<Parameters<typeof hasUnpublishedClaimResponseKindEdit>[0]>;
+
+    expect(hasUnpublishedClaimResponseKindEdit(entity, SPACE_ID)).toBe(true);
+  });
+
+  it('keeps polling until Gaia serves the expected response', async () => {
+    const indexedResponses = [null, null, 'positive'] as const;
+    let attempt = 0;
+
+    await expect(
+      waitForIndexedEntityResponse(
+        async () => indexedResponses[Math.min(attempt++, indexedResponses.length - 1)] ?? null,
+        'positive',
+        3,
+        0
+      )
+    ).resolves.toBe(true);
+    expect(attempt).toBe(3);
+  });
+
+  it('treats a cleared Gaia response as indexed and tolerates transient failures', async () => {
+    let attempt = 0;
+
+    await expect(
+      waitForIndexedEntityResponse(
+        async () => {
+          attempt += 1;
+          if (attempt === 1) throw new Error('temporarily unavailable');
+          return null;
+        },
+        null,
+        2,
+        0
+      )
+    ).resolves.toBe(true);
+    expect(attempt).toBe(2);
+  });
+
+  it('aborts and retries a Gaia probe that never settles', async () => {
+    vi.useFakeTimers();
+    let aborted = false;
+    const polling = waitForIndexedEntityResponse(
+      signal =>
+        new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            aborted = true;
+            reject(new Error('aborted'));
+          });
+        }),
+      'positive',
+      1,
+      0,
+      50
+    );
+
+    await vi.advanceTimersByTimeAsync(50);
+
+    await expect(polling).resolves.toBe(false);
+    expect(aborted).toBe(true);
+    vi.useRealTimers();
+  });
+
+  it('stops polling when a reconciliation run is superseded', async () => {
+    const controller = new AbortController();
+    let attempts = 0;
+    const polling = waitForIndexedEntityResponse(
+      signal => {
+        attempts += 1;
+        return new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () => reject(new Error('aborted')));
+        });
+      },
+      'positive',
+      30,
+      2_000,
+      5_000,
+      controller.signal
+    );
+    await Promise.resolve();
+
+    controller.abort();
+
+    await expect(polling).resolves.toBe(false);
+    expect(attempts).toBe(1);
+  });
+});
+
+describe('entity response query keys', () => {
+  it('builds exact-space and exact-kind query variables', () => {
+    expect(entityResponseQueryVariables('entity', 'space', 0, 'stance')).toEqual({
+      objectId: 'entity',
+      objectType: 0,
+      spaceId: 'space',
+      voteKind: 1,
+    });
+  });
+
+  it('includes exact space and response kind in cache keys', () => {
+    expect(entityResponseCountsQueryKey('entity', 'space', 0, 'stance')).toEqual([
+      'entity-response-counts',
+      'entity',
+      'space',
+      0,
+      'stance',
+    ]);
+    expect(userEntityResponseQueryKey('user', 'entity', 'space', 0, 'veracity')).toEqual([
+      'user-entity-response',
+      'user',
+      'entity',
+      'space',
+      0,
+      'veracity',
+    ]);
+    expect(entityRespondersQueryKey('entity', 'space', 0, 'curation')).toEqual([
+      'entity-responders',
+      'entity',
+      'space',
+      0,
+      'curation',
+    ]);
+    expect(entityResponseIndexingQueryKey('profile-space', 'entity', 'space', 'stance')).toEqual([
+      'entity-response-indexing',
+      'profile-space',
+      'entity',
+      'space',
+      'stance',
+    ]);
+  });
+});
diff --git a/apps/web/core/responses/entity-response.ts b/apps/web/core/responses/entity-response.ts
new file mode 100644
index 0000000000..9b927e25bd
--- /dev/null
+++ b/apps/web/core/responses/entity-response.ts
@@ -0,0 +1,259 @@
+import { SystemIds } from '@geoprotocol/geo-sdk/lite';
+
+import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID } from '~/core/claims/ontology';
+import { uuidToHex } from '~/core/id/normalize';
+import type { Entity } from '~/core/types';
+import { sleep } from '~/core/utils/utils';
+
+export type ResponseKind = 'curation' | 'stance' | 'veracity';
+export type ResponseDirection = 'positive' | 'negative' | 'clear';
+export type ActiveResponseDirection = Exclude<ResponseDirection, 'clear'>;
+export type ResponseVoteKind = 0 | 1 | 2;
+export type ResponseObjectType = 0 | 1;
+
+export type ResponseActionMethod =
+  'upvote' | 'downvote' | 'unvote' | 'agree' | 'disagree' | 'unagree' | 'verify' | 'dispute' | 'unverify';
+
+const RESPONSE_VOTE_KIND: Record<ResponseKind, ResponseVoteKind> = {
+  curation: 0,
+  stance: 1,
+  veracity: 2,
+};
+
+const CLAIM_TYPE = uuidToHex(CLAIM_TYPE_ID);
+const CLAIM_IS_FACTUAL = uuidToHex(CLAIM_IS_FACTUAL_PROPERTY_ID);
+const TYPES_PROPERTY = uuidToHex(SystemIds.TYPES_PROPERTY);
+
+const RESPONSE_ACTION_METHOD: Record<ResponseKind, Record<ResponseDirection, ResponseActionMethod>> = {
+  curation: {
+    positive: 'upvote',
+    negative: 'downvote',
+    clear: 'unvote',
+  },
+  stance: {
+    positive: 'agree',
+    negative: 'disagree',
+    clear: 'unagree',
+  },
+  veracity: {
+    positive: 'verify',
+    negative: 'dispute',
+    clear: 'unverify',
+  },
+};
+
+export type EntityResponseCopy = {
+  positiveAction: string;
+  negativeAction: string;
+  removePositive: string;
+  removeNegative: string;
+  positiveSection: string;
+  negativeSection: string;
+  empty: string;
+  loading: string;
+  viewResponders: string;
+  signIn: string;
+  connect: string;
+};
+
+export const ENTITY_RESPONSE_COPY: Record<ResponseKind, EntityResponseCopy> = {
+  curation: {
+    positiveAction: 'Upvote',
+    negativeAction: 'Downvote',
+    removePositive: 'Remove upvote',
+    removeNegative: 'Remove downvote',
+    positiveSection: 'Upvotes',
+    negativeSection: 'Downvotes',
+    empty: 'No votes yet',
+    loading: 'Loading voters…',
+    viewResponders: 'View voters',
+    signIn: 'Sign in to vote',
+    connect: 'Connect wallet to vote',
+  },
+  stance: {
+    positiveAction: 'Agree',
+    negativeAction: 'Disagree',
+    removePositive: 'Remove agreement',
+    removeNegative: 'Remove disagreement',
+    positiveSection: 'Agreements',
+    negativeSection: 'Disagreements',
+    empty: 'No stances yet',
+    loading: 'Loading responders…',
+    viewResponders: 'View stances',
+    signIn: 'Sign in to respond',
+    connect: 'Connect wallet to respond',
+  },
+  veracity: {
+    positiveAction: 'Verify',
+    negativeAction: 'Dispute',
+    removePositive: 'Remove verification',
+    removeNegative: 'Remove dispute',
+    positiveSection: 'Verifications',
+    negativeSection: 'Disputes',
+    empty: 'No veracity responses yet',
+    loading: 'Loading responders…',
+    viewResponders: 'View veracity responses',
+    signIn: 'Sign in to respond',
+    connect: 'Connect wallet to respond',
+  },
+};
+
+export function responsePositionLabel(responseKind: 'stance' | 'veracity' | null, position: boolean) {
+  const copy = ENTITY_RESPONSE_COPY[responseKind ?? 'stance'];
+  return position ? copy.positiveAction : copy.negativeAction;
+}
+
+export function getEntityResponseKind({ isClaim, isFactual }: { isClaim: boolean; isFactual: boolean }): ResponseKind {
+  if (!isClaim) return 'curation';
+  return isFactual ? 'veracity' : 'stance';
+}
+
+export function hasUnpublishedClaimResponseKindEdit(
+  entity: Pick<Entity, 'relations' | 'values'> | null | undefined,
+  spaceId: string
+) {
+  return (
+    entity?.values.some(
+      value =>
+        uuidToHex(value.spaceId) === uuidToHex(spaceId) &&
+        uuidToHex(value.property.id) === CLAIM_IS_FACTUAL &&
+        value.isLocal === true &&
+        value.hasBeenPublished !== true
+    ) ||
+    entity?.relations.some(
+      relation =>
+        uuidToHex(relation.spaceId) === uuidToHex(spaceId) &&
+        uuidToHex(relation.type.id) === TYPES_PROPERTY &&
+        uuidToHex(relation.toEntity.id) === CLAIM_TYPE &&
+        relation.isLocal === true &&
+        relation.hasBeenPublished !== true
+    ) ||
+    false
+  );
+}
+
+export function responseKindToVoteKind(kind: ResponseKind): ResponseVoteKind {
+  return RESPONSE_VOTE_KIND[kind];
+}
+
+export function getResponseActionMethod(kind: ResponseKind, direction: ResponseDirection): ResponseActionMethod {
+  return RESPONSE_ACTION_METHOD[kind][direction];
+}
+
+export function decodeActiveResponseDirection(voteType: unknown): ActiveResponseDirection | null {
+  if (voteType === 0) return 'positive';
+  if (voteType === 1) return 'negative';
+  return null;
+}
+
+export async function waitForIndexedEntityResponse(
+  fetchResponse: (signal: AbortSignal) => Promise<ActiveResponseDirection | null>,
+  expectedResponse: ActiveResponseDirection | null,
+  maxAttempts = 30,
+  intervalMs = 2_000,
+  probeTimeoutMs = 5_000,
+  signal?: AbortSignal
+): Promise<boolean> {
+  const deadline = Date.now() + Math.max(probeTimeoutMs, maxAttempts * intervalMs);
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (signal?.aborted) return false;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) return false;
+    const controller = new AbortController();
+    let rejectTimeout: ((reason: Error) => void) | undefined;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      rejectTimeout = reject;
+    });
+    const abortProbe = () => {
+      controller.abort();
+      rejectTimeout?.(new Error('Response indexing reconciliation was superseded'));
+    };
+    signal?.addEventListener('abort', abortProbe, { once: true });
+    const timeoutId = setTimeout(
+      () => {
+        controller.abort();
+        rejectTimeout?.(new Error('Timed out waiting for Gaia response indexing'));
+      },
+      Math.min(probeTimeoutMs, remainingMs)
+    );
+
+    try {
+      if ((await Promise.race([fetchResponse(controller.signal), timeoutPromise])) === expectedResponse) {
+        return true;
+      }
+    } catch {
+      // Gaia can fail transiently while indexing. Keep the transaction in its
+      // processing state and retry instead of presenting a false write error.
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener('abort', abortProbe);
+    }
+
+    if (attempt < maxAttempts) {
+      if (signal?.aborted) return false;
+      await sleep(intervalMs);
+    }
+  }
+
+  return false;
+}
+
+export function entityResponseQueryVariables(
+  entityId: string,
+  spaceId: string,
+  objectType: ResponseObjectType,
+  responseKind: ResponseKind
+) {
+  return {
+    objectId: entityId,
+    objectType,
+    spaceId,
+    voteKind: responseKindToVoteKind(responseKind),
+  } as const;
+}
+
+export function entityResponseCountsQueryKey(
+  entityId: string,
+  spaceId: string,
+  objectType: ResponseObjectType,
+  responseKind: ResponseKind
+) {
+  return ['entity-response-counts', entityId, spaceId, objectType, responseKind] as const;
+}
+
+export function userEntityResponseQueryKey(
+  userId: string | null | undefined,
+  entityId: string,
+  spaceId: string,
+  objectType: ResponseObjectType,
+  responseKind: ResponseKind
+) {
+  return ['user-entity-response', userId, entityId, spaceId, objectType, responseKind] as const;
+}
+
+export function entityResponseIndexingQueryKey(
+  personalSpaceId: string | null,
+  entityId: string,
+  spaceId: string,
+  responseKind: ResponseKind | null
+) {
+  return ['entity-response-indexing', personalSpaceId, entityId, spaceId, responseKind] as const;
+}
+
+export function entityRespondersQueryKey(
+  entityId: string,
+  spaceId: string,
+  objectType: ResponseObjectType,
+  responseKind: ResponseKind
+) {
+  return ['entity-responders', entityId, spaceId, objectType, responseKind] as const;
+}
+
+export function entityResponderProfilesQueryKey(
+  entityId: string,
+  spaceId: string,
+  objectType: ResponseObjectType,
+  responseKind: ResponseKind
+) {
+  return ['entity-responder-profiles', entityId, spaceId, objectType, responseKind] as const;
+}
diff --git a/apps/web/core/responses/use-claim-response-summaries.test.tsx b/apps/web/core/responses/use-claim-response-summaries.test.tsx
new file mode 100644
index 0000000000..37624cd4e2
--- /dev/null
+++ b/apps/web/core/responses/use-claim-response-summaries.test.tsx
@@ -0,0 +1,171 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useClaimResponseSummaryBatch } from './use-claim-response-summaries';
+
+const mocks = vi.hoisted(() => ({
+  loadCaches: vi.fn(),
+  loadMetadataCaches: vi.fn(),
+  personalSpaceId: 'profile-1' as string | null,
+  personalSpaceLoading: false,
+}));
+
+vi.mock('~/core/hooks/use-personal-space-id', () => ({
+  usePersonalSpaceId: () => ({
+    personalSpaceId: mocks.personalSpaceId,
+    isRegistered: true,
+    isLoading: mocks.personalSpaceLoading,
+  }),
+}));
+
+vi.mock('./claim-response-summaries', async importOriginal => {
+  const actual = await importOriginal<typeof import('./claim-response-summaries')>();
+  return {
+    ...actual,
+    loadClaimResponseSummaryCaches: (...args: unknown[]) => mocks.loadCaches(...args),
+    loadClaimResponderMetadataCaches: (...args: unknown[]) => mocks.loadMetadataCaches(...args),
+  };
+});
+
+beforeEach(() => {
+  mocks.loadCaches.mockReset();
+  mocks.loadCaches.mockResolvedValue(new Map());
+  mocks.loadMetadataCaches.mockReset();
+  mocks.loadMetadataCaches.mockResolvedValue(undefined);
+  mocks.personalSpaceId = 'profile-1';
+  mocks.personalSpaceLoading = false;
+});
+
+describe('useClaimResponseSummaryBatch', () => {
+  it('loads all 50 visible claim-kind pairs through one batch query function', async () => {
+    const targets = Array.from({ length: 50 }, (_, index) => ({
+      entityId: `claim-${index}`,
+      responseKind: index % 2 === 0 ? ('stance' as const) : ('veracity' as const),
+    }));
+    const { wrapper } = createHarness();
+
+    const { result } = renderHook(() => useClaimResponseSummaryBatch({ spaceId: 'space-1', targets, enabled: true }), {
+      wrapper,
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(mocks.loadCaches).toHaveBeenCalledOnce();
+    expect(mocks.loadCaches).toHaveBeenCalledWith(
+      expect.objectContaining({
+        spaceId: 'space-1',
+        personalSpaceId: 'profile-1',
+        targets: expect.arrayContaining(targets),
+      })
+    );
+  });
+
+  it('isolates the batch cache by viewer account and exact space', async () => {
+    const { queryClient, wrapper } = createHarness();
+    const targets = [{ entityId: 'claim-1', responseKind: 'stance' as const }];
+    const first = renderHook(() => useClaimResponseSummaryBatch({ spaceId: 'space-1', targets, enabled: true }), {
+      wrapper,
+    });
+    await waitFor(() => expect(first.result.current.isSuccess).toBe(true));
+
+    mocks.personalSpaceId = 'profile-2';
+    first.rerender();
+    await waitFor(() => expect(mocks.loadCaches).toHaveBeenCalledTimes(2));
+
+    expect(
+      queryClient.getQueryState(['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']])?.status
+    ).toBe('success');
+    expect(
+      queryClient.getQueryState(['claim-response-summaries', 'profile-2', 'space-1', ['claim-1:stance']])?.status
+    ).toBe('success');
+  });
+
+  it('starts a separate batch when the exact space changes', async () => {
+    const { queryClient, wrapper } = createHarness();
+    const targets = [{ entityId: 'claim-1', responseKind: 'stance' as const }];
+    const { result, rerender } = renderHook(
+      ({ spaceId }) => useClaimResponseSummaryBatch({ spaceId, targets, enabled: true }),
+      { wrapper, initialProps: { spaceId: 'space-1' } }
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    rerender({ spaceId: 'space-2' });
+    await waitFor(() => expect(mocks.loadCaches).toHaveBeenCalledTimes(2));
+
+    expect(mocks.loadCaches.mock.calls.map(call => (call[0] as { spaceId: string }).spaceId)).toEqual([
+      'space-1',
+      'space-2',
+    ]);
+    expect(
+      queryClient.getQueryState(['claim-response-summaries', 'profile-1', 'space-1', ['claim-1:stance']])?.status
+    ).toBe('success');
+    expect(
+      queryClient.getQueryState(['claim-response-summaries', 'profile-1', 'space-2', ['claim-1:stance']])?.status
+    ).toBe('success');
+  });
+
+  it('waits for the viewer identity query before starting the batch', async () => {
+    mocks.personalSpaceId = null;
+    mocks.personalSpaceLoading = true;
+    const { wrapper } = createHarness();
+    const targets = [{ entityId: 'claim-1', responseKind: 'stance' as const }];
+    const { result, rerender } = renderHook(
+      () => useClaimResponseSummaryBatch({ spaceId: 'space-1', targets, enabled: true }),
+      { wrapper }
+    );
+
+    expect(result.current.fetchStatus).toBe('idle');
+    expect(mocks.loadCaches).not.toHaveBeenCalled();
+
+    mocks.personalSpaceId = 'profile-1';
+    mocks.personalSpaceLoading = false;
+    rerender();
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(mocks.loadCaches).toHaveBeenCalledOnce();
+    expect(mocks.loadCaches).toHaveBeenCalledWith(expect.objectContaining({ personalSpaceId: 'profile-1' }));
+  });
+
+  it('keeps the response batch successful when avatar enrichment fails', async () => {
+    mocks.loadCaches.mockResolvedValue(
+      new Map([
+        [
+          'claim-1:stance',
+          {
+            counts: { positive: 1, negative: 0 },
+            viewerResponse: null,
+            responders: [{ userId: 'profile-2', direction: 'positive' }],
+          },
+        ],
+      ])
+    );
+    mocks.loadMetadataCaches.mockRejectedValue(new Error('avatar metadata unavailable'));
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () =>
+        useClaimResponseSummaryBatch({
+          spaceId: 'space-1',
+          targets: [{ entityId: 'claim-1', responseKind: 'stance' }],
+          enabled: true,
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    await waitFor(() => expect(mocks.loadMetadataCaches).toHaveBeenCalled());
+    expect(result.current.isError).toBe(false);
+  });
+});
+
+function createHarness() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return {
+    queryClient,
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  };
+}
diff --git a/apps/web/core/responses/use-claim-response-summaries.ts b/apps/web/core/responses/use-claim-response-summaries.ts
new file mode 100644
index 0000000000..287889a1b4
--- /dev/null
+++ b/apps/web/core/responses/use-claim-response-summaries.ts
@@ -0,0 +1,83 @@
+'use client';
+
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+
+import * as React from 'react';
+
+import { usePersonalSpaceId } from '~/core/hooks/use-personal-space-id';
+
+import {
+  type ClaimResponseTarget,
+  claimResponseSummariesQueryKeyPrefix,
+  claimResponseSummaryResponderSpaceIds,
+  claimResponseTargetKey,
+  loadClaimResponderMetadataCaches,
+  loadClaimResponseSummaryCaches,
+  normalizeClaimResponseTargets,
+} from './claim-response-summaries';
+
+const ClaimResponseBatchContext = React.createContext({ managed: false, ready: true });
+
+export function ClaimResponseBatchBoundary({ ready, children }: { ready: boolean; children: React.ReactNode }) {
+  const value = React.useMemo(() => ({ managed: true, ready }), [ready]);
+  return React.createElement(ClaimResponseBatchContext.Provider, { value }, children);
+}
+
+export function useClaimResponseBatchState() {
+  return React.useContext(ClaimResponseBatchContext);
+}
+
+export function useClaimResponseSummaryBatch({
+  spaceId,
+  targets,
+  enabled,
+}: {
+  spaceId: string;
+  targets: ClaimResponseTarget[];
+  enabled: boolean;
+}) {
+  const queryClient = useQueryClient();
+  const { personalSpaceId, isLoading: isPersonalSpaceLoading } = usePersonalSpaceId();
+  const normalizedTargets = normalizeClaimResponseTargets(targets);
+
+  const responseBatch = useQuery({
+    queryKey: [
+      ...claimResponseSummariesQueryKeyPrefix(personalSpaceId, spaceId),
+      normalizedTargets.map(claimResponseTargetKey),
+    ],
+    queryFn: ({ signal }) =>
+      loadClaimResponseSummaryCaches({
+        queryClient,
+        spaceId,
+        targets: normalizedTargets,
+        personalSpaceId,
+        signal,
+      }),
+    enabled: enabled && !isPersonalSpaceLoading && normalizedTargets.length > 0,
+    staleTime: 30_000,
+    retry: 2,
+  });
+  const responderSpaceIds = responseBatch.data ? claimResponseSummaryResponderSpaceIds(responseBatch.data) : [];
+
+  useQuery({
+    queryKey: [
+      'claim-response-responder-metadata',
+      spaceId,
+      normalizedTargets.map(claimResponseTargetKey),
+      responderSpaceIds,
+    ],
+    queryFn: ({ signal }) =>
+      loadClaimResponderMetadataCaches({
+        queryClient,
+        spaceId,
+        targets: normalizedTargets,
+        summaries: responseBatch.data!,
+        signal,
+      }),
+    enabled: responseBatch.isSuccess && responderSpaceIds.length > 0,
+    staleTime: 60_000,
+    retry: 2,
+  });
+
+  return responseBatch;
+}
diff --git a/apps/web/core/sync/orm.ts b/apps/web/core/sync/orm.ts
index 143776c27d..810cf131fe 100644
--- a/apps/web/core/sync/orm.ts
+++ b/apps/web/core/sync/orm.ts
@@ -4,8 +4,9 @@ import { QueryClient } from '@tanstack/react-query';
 import { Effect } from 'effect';
 import { dedupeWith } from 'effect/Array';
 
-import { type EntitiesOrderBy, SortOrder } from '~/core/gql/graphql';
+import { type EntitiesOrderBy } from '~/core/gql/graphql';
 import { convertWhereConditionToEntityFilter, extractTypeIdsFromWhere } from '~/core/io/converters';
+import { SortOrder } from '~/core/io/sort-order';
 
 import { readTypes } from '../database/entities';
 import {
diff --git a/apps/web/core/sync/use-store.tsx b/apps/web/core/sync/use-store.tsx
index d8810b4e89..a3e9021055 100644
--- a/apps/web/core/sync/use-store.tsx
+++ b/apps/web/core/sync/use-store.tsx
@@ -25,6 +25,7 @@ import { useSyncEngine } from './use-sync-engine';
 type QueryEntityOptions = {
   id?: string;
   spaceId?: string;
+  includeDeleted?: boolean;
   /**
    * By default we query the local store for the entity without
    * querying the remote server. This assumes that the entity
@@ -204,7 +205,7 @@ export function useHydrateEntities({ ids, enabled = true, spaceId }: HydrateEnti
  * not stable (as of July 2025). Once it's stable we should just
  * migrate to @tanstack/db and use that instead.
  */
-export function useQueryEntity({ id, spaceId, enabled = true }: QueryEntityOptions) {
+export function useQueryEntity({ id, spaceId, includeDeleted = false, enabled = true }: QueryEntityOptions) {
   const { store } = useSyncEngine();
   const { isFetched } = useHydrateEntity({ id, enabled });
 
@@ -215,7 +216,7 @@ export function useQueryEntity({ id, spaceId, enabled = true }: QueryEntityOptio
         return null;
       }
 
-      return store.getEntity(id, { spaceId }) ?? null;
+      return store.getEntity(id, { includeDeleted, spaceId }) ?? null;
     },
     equal
   );
diff --git a/apps/web/partials/blocks/table/ranking-period-metadata.tsx b/apps/web/partials/blocks/table/ranking-period-metadata.tsx
index 1bec139649..919ac1de62 100644
--- a/apps/web/partials/blocks/table/ranking-period-metadata.tsx
+++ b/apps/web/partials/blocks/table/ranking-period-metadata.tsx
@@ -11,6 +11,7 @@ import type { RankingPeriodState } from '~/core/blocks/ranking/ranking-period';
 import type { RankingSubmissionRecord } from '~/core/blocks/ranking/ranking-submission-types';
 import { PLACEHOLDER_SPACE_IMAGE } from '~/core/constants';
 import { useSpacesByIds } from '~/core/hooks/use-spaces-by-ids';
+import { profilesBySpaceIdsQueryKey } from '~/core/io/query-keys';
 import { fetchProfilesBySpaceIds } from '~/core/io/subgraph/fetch-profile';
 
 import { Avatar } from '~/design-system/avatar';
@@ -94,23 +95,25 @@ export function RankingAggregatedSubmitterAvatars({
   totalCount,
   maxVisible = VISIBLE_RANKED_BY_AVATARS,
   size = RANKED_BY_AVATAR_SIZE,
+  queriesEnabled = true,
 }: {
   submitterSpaceIds: string[];
   totalCount?: number;
   maxVisible?: number;
   size?: 12 | 20;
+  queriesEnabled?: boolean;
 }) {
   const uniqueSpaceIds = React.useMemo(() => dedupePreserveOrder(submitterSpaceIds), [submitterSpaceIds]);
   const { data: profilesBySpaceId = new Map() } = useQuery({
-    queryKey: ['ranking-submitter-profiles', uniqueSpaceIds],
-    enabled: uniqueSpaceIds.length > 0,
+    queryKey: profilesBySpaceIdsQueryKey(uniqueSpaceIds),
+    enabled: queriesEnabled && uniqueSpaceIds.length > 0,
     staleTime: 60_000,
     queryFn: async () => {
       const profiles = await Effect.runPromise(fetchProfilesBySpaceIds(uniqueSpaceIds));
       return new Map(uniqueSpaceIds.map((spaceId, index) => [spaceId, profiles[index]!]));
     },
   });
-  const { spacesById } = useSpacesByIds(uniqueSpaceIds);
+  const { spacesById } = useSpacesByIds(uniqueSpaceIds, queriesEnabled);
 
   const resolveAvatarUrl = React.useCallback(
     (spaceId: string) => {
diff --git a/apps/web/partials/entity-page/claim-voter-avatars.test.tsx b/apps/web/partials/entity-page/claim-voter-avatars.test.tsx
new file mode 100644
index 0000000000..b41a3a4873
--- /dev/null
+++ b/apps/web/partials/entity-page/claim-voter-avatars.test.tsx
@@ -0,0 +1,75 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import '@testing-library/jest-dom/vitest';
+import { cleanup, render, screen } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { entityRespondersQueryKey } from '~/core/responses/entity-response';
+
+import { ClaimResponderAvatars } from './claim-voter-avatars';
+
+vi.mock('~/core/responses/use-claim-response-summaries', () => ({
+  useClaimResponseBatchState: () => ({ managed: true, ready: true }),
+}));
+
+vi.mock('~/partials/blocks/table/ranking-period-metadata', () => ({
+  RankingAggregatedSubmitterAvatars: ({
+    submitterSpaceIds,
+    totalCount,
+  }: {
+    submitterSpaceIds: string[];
+    totalCount: number;
+  }) => (
+    <div>
+      <span data-testid="responder-ids">{submitterSpaceIds.join(',')}</span>
+      <span data-testid="responder-count">{totalCount}</span>
+    </div>
+  ),
+}));
+
+afterEach(cleanup);
+
+describe('ClaimResponderAvatars', () => {
+  it('adds and removes the viewer avatar with the optimistic response', () => {
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    queryClient.setQueryData(entityRespondersQueryKey('claim-1', 'space-1', 0, 'stance'), [
+      { userId: 'profile-other', direction: 'negative' },
+    ]);
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+
+    const view = render(
+      <ClaimResponderAvatars
+        entityId="claim-1"
+        spaceId="space-1"
+        objectType={0}
+        responseKind="stance"
+        totalResponders={2}
+        viewerSpaceId="profile-viewer"
+        optimisticViewerResponse="positive"
+      />,
+      { wrapper }
+    );
+
+    expect(screen.getByTestId('responder-ids')).toHaveTextContent('profile-viewer,profile-other');
+    expect(screen.getByTestId('responder-count')).toHaveTextContent('2');
+
+    view.rerender(
+      <ClaimResponderAvatars
+        entityId="claim-1"
+        spaceId="space-1"
+        objectType={0}
+        responseKind="stance"
+        totalResponders={1}
+        viewerSpaceId="profile-viewer"
+        optimisticViewerResponse={null}
+      />
+    );
+
+    expect(screen.getByTestId('responder-ids')).toHaveTextContent('profile-other');
+    expect(screen.getByTestId('responder-count')).toHaveTextContent('1');
+  });
+});
diff --git a/apps/web/partials/entity-page/claim-voter-avatars.tsx b/apps/web/partials/entity-page/claim-voter-avatars.tsx
index 2bace34052..a803b852be 100644
--- a/apps/web/partials/entity-page/claim-voter-avatars.tsx
+++ b/apps/web/partials/entity-page/claim-voter-avatars.tsx
@@ -6,36 +6,58 @@ import * as React from 'react';
 
 import { Effect } from 'effect';
 
-import { getEntityVoters } from '~/core/io/queries';
+import { getEntityResponders } from '~/core/io/queries';
+import {
+  type ActiveResponseDirection,
+  type ResponseKind,
+  type ResponseObjectType,
+  entityRespondersQueryKey,
+} from '~/core/responses/entity-response';
+import { useClaimResponseBatchState } from '~/core/responses/use-claim-response-summaries';
 
 import { RankingAggregatedSubmitterAvatars } from '~/partials/blocks/table/ranking-period-metadata';
 
-export function ClaimVoterAvatars({
+export function ClaimResponderAvatars({
   entityId,
   spaceId,
   objectType,
-  totalVoters,
+  responseKind,
+  totalResponders,
+  viewerSpaceId,
+  optimisticViewerResponse,
 }: {
   entityId: string;
   spaceId: string;
-  objectType: 0 | 1;
-  totalVoters: number;
+  objectType: ResponseObjectType;
+  responseKind: ResponseKind;
+  totalResponders: number;
+  viewerSpaceId?: string | null;
+  optimisticViewerResponse?: ActiveResponseDirection | null;
 }) {
-  const { data: voters } = useQuery({
-    queryKey: ['entity-voter-list', entityId, spaceId, objectType],
-    queryFn: () => Effect.runPromise(getEntityVoters(entityId, spaceId, objectType)),
+  const responseBatch = useClaimResponseBatchState();
+  const { data: responders } = useQuery({
+    queryKey: entityRespondersQueryKey(entityId, spaceId, objectType, responseKind),
+    queryFn: () => Effect.runPromise(getEntityResponders(entityId, spaceId, responseKind, objectType)),
+    enabled: !responseBatch.managed,
     staleTime: 30_000,
   });
 
-  const voterSpaceIds = React.useMemo(() => voters?.map(v => v.userId) ?? [], [voters]);
+  const responderSpaceIds = React.useMemo(() => {
+    const indexedResponderIds = responders?.map(v => v.userId) ?? [];
+    if (optimisticViewerResponse === undefined || !viewerSpaceId) return indexedResponderIds;
 
-  if (voterSpaceIds.length === 0) return null;
+    const otherResponderIds = indexedResponderIds.filter(id => id !== viewerSpaceId);
+    return optimisticViewerResponse === null ? otherResponderIds : [viewerSpaceId, ...otherResponderIds];
+  }, [optimisticViewerResponse, responders, viewerSpaceId]);
+
+  if (responderSpaceIds.length === 0) return null;
 
   return (
     <RankingAggregatedSubmitterAvatars
-      submitterSpaceIds={voterSpaceIds}
-      totalCount={Math.max(totalVoters, voterSpaceIds.length)}
+      submitterSpaceIds={responderSpaceIds}
+      totalCount={Math.max(totalResponders, responderSpaceIds.length)}
       size={12}
+      queriesEnabled={!responseBatch.managed}
     />
   );
 }
diff --git a/apps/web/partials/entity-page/entity-page-metadata-header.tsx b/apps/web/partials/entity-page/entity-page-metadata-header.tsx
index ef1f14c41e..3c98a4c7ea 100644
--- a/apps/web/partials/entity-page/entity-page-metadata-header.tsx
+++ b/apps/web/partials/entity-page/entity-page-metadata-header.tsx
@@ -290,8 +290,8 @@ export function EntityPageMetadataHeader({ id, spaceId, isVoteable = false }: En
         )}
       </div>
       <div className="flex items-center gap-2">
-        <ClaimDebateButton entityId={id} spaceId={spaceId} entity={entity} />
         {isVoteable && <EntityVoteButtons entityId={id} spaceId={spaceId} />}
+        <ClaimDebateButton entityId={id} spaceId={spaceId} entity={entity} />
       </div>
     </div>
   );
diff --git a/apps/web/partials/entity-page/entity-vote-buttons.batch.test.tsx b/apps/web/partials/entity-page/entity-vote-buttons.batch.test.tsx
new file mode 100644
index 0000000000..4a497ded4f
--- /dev/null
+++ b/apps/web/partials/entity-page/entity-vote-buttons.batch.test.tsx
@@ -0,0 +1,237 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import '@testing-library/jest-dom/vitest';
+import { cleanup, fireEvent, render, waitFor } from '@testing-library/react';
+
+import type { ReactNode } from 'react';
+
+import { Effect } from 'effect';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { entityResponseCountsQueryKey, userEntityResponseQueryKey } from '~/core/responses/entity-response';
+import {
+  ClaimResponseBatchBoundary,
+  useClaimResponseSummaryBatch,
+} from '~/core/responses/use-claim-response-summaries';
+
+import { EntityVoteButtons } from './entity-vote-buttons';
+
+const mocks = vi.hoisted(() => ({
+  getCounts: vi.fn(),
+  getResponders: vi.fn(),
+  getSummaryPage: vi.fn(),
+  getViewerResponse: vi.fn(),
+  optimisticResponse: undefined as 'positive' | 'negative' | null | undefined,
+  queryEntityOptions: [] as unknown[],
+  smartAccount: null as object | null,
+  submitResponse: vi.fn(),
+  responderAvatarProps: [] as unknown[],
+}));
+
+vi.mock('@geogenesis/auth', () => ({
+  useGeoLogin: () => ({ login: vi.fn() }),
+}));
+
+vi.mock('~/core/analytics', () => ({
+  downvoted: vi.fn(),
+  trackPrivyAuth: vi.fn(),
+  upvoted: vi.fn(),
+  voteCast: vi.fn(),
+}));
+
+vi.mock('~/core/hooks/use-entity-vote', () => ({
+  useEntityResponse: () => ({
+    submitResponse: mocks.submitResponse,
+    optimisticResponse: mocks.optimisticResponse,
+    isResponseIndexingDelayed: false,
+    isConnected: true,
+    personalSpaceId: 'profile-1',
+  }),
+}));
+
+vi.mock('~/core/hooks/use-personal-space-id', () => ({
+  usePersonalSpaceId: () => ({ personalSpaceId: 'profile-1', isRegistered: true, isLoading: false }),
+}));
+
+vi.mock('~/core/hooks/use-smart-account', () => ({
+  useSmartAccount: () => ({ smartAccount: mocks.smartAccount }),
+}));
+
+vi.mock('~/core/io/queries', () => ({
+  getClaimResponseSummaryPage: (...args: unknown[]) => Effect.succeed(mocks.getSummaryPage(...args)),
+  getEntityResponseCounts: (...args: unknown[]) => Effect.succeed(mocks.getCounts(...args)),
+  getEntityResponders: (...args: unknown[]) => Effect.succeed(mocks.getResponders(...args)),
+  getSpaces: () => Effect.succeed([]),
+  getUserEntityResponse: (...args: unknown[]) => Effect.succeed(mocks.getViewerResponse(...args)),
+}));
+
+vi.mock('~/core/io/subgraph/fetch-profile', () => ({
+  fetchProfilesBySpaceIds: () => Effect.succeed([]),
+}));
+
+vi.mock('~/core/state/pending-personal-space', () => ({
+  usePendingPersonalSpace: () => ({ isPending: false }),
+}));
+
+vi.mock('~/core/sync/use-store', () => ({
+  useQueryEntity: (options: unknown) => {
+    mocks.queryEntityOptions.push(options);
+    return { entity: null, isLoading: false };
+  },
+}));
+
+vi.mock('~/partials/entity-page/claim-voter-avatars', () => ({
+  ClaimResponderAvatars: (props: unknown) => {
+    mocks.responderAvatarProps.push(props);
+    return null;
+  },
+}));
+
+beforeEach(() => {
+  mocks.getCounts.mockReset();
+  mocks.getCounts.mockReturnValue({ positive: 2, negative: 1 });
+  mocks.getResponders.mockReset();
+  mocks.getResponders.mockReturnValue([]);
+  mocks.getSummaryPage.mockReset();
+  mocks.getSummaryPage.mockReturnValue([]);
+  mocks.getViewerResponse.mockReset();
+  mocks.getViewerResponse.mockReturnValue('positive');
+  mocks.optimisticResponse = undefined;
+  mocks.queryEntityOptions.length = 0;
+  mocks.smartAccount = null;
+  mocks.submitResponse.mockReset();
+  mocks.responderAvatarProps.length = 0;
+});
+
+afterEach(cleanup);
+
+describe('EntityVoteButtons claims-page batching', () => {
+  it('skips entity hydration and all individual response queries while the page batch is unresolved', async () => {
+    const view = renderButtons(false);
+
+    expect(view.container.querySelector('.animate-pulse')).toBeInTheDocument();
+    expect(mocks.queryEntityOptions.at(-1)).toMatchObject({ enabled: false });
+    await Promise.resolve();
+    expect(mocks.getCounts).not.toHaveBeenCalled();
+    expect(mocks.getViewerResponse).not.toHaveBeenCalled();
+    expect(mocks.getResponders).not.toHaveBeenCalled();
+  });
+
+  it('uses the batch-seeded caches without fetching or hydrating Entity once batching resolves', async () => {
+    renderButtons(true, true);
+
+    await waitFor(() => expect(mocks.queryEntityOptions).toHaveLength(1));
+    expect(mocks.getCounts).not.toHaveBeenCalled();
+    expect(mocks.getViewerResponse).not.toHaveBeenCalled();
+    expect(mocks.queryEntityOptions.at(-1)).toMatchObject({ enabled: false });
+  });
+
+  it('renders factual claims with the original chevron controls and no explanatory label', () => {
+    const view = renderButtons(true, true, 'veracity');
+
+    expect(view.queryByText('Is factual')).not.toBeInTheDocument();
+    const responseIcons = [...view.container.querySelectorAll('svg')];
+    expect(responseIcons).toHaveLength(2);
+    expect(responseIcons.every(icon => icon.getAttribute('viewBox') === '0 0 16 16')).toBe(true);
+  });
+
+  it('passes the optimistic viewer response to responder avatars immediately', () => {
+    mocks.optimisticResponse = 'negative';
+
+    renderButtons(true, true);
+
+    expect(mocks.responderAvatarProps.at(-1)).toMatchObject({
+      optimisticViewerResponse: 'negative',
+      totalResponders: 3,
+      viewerSpaceId: 'profile-1',
+    });
+  });
+
+  it('wires optimistic claim response changes without blocking subsequent clicks', () => {
+    mocks.smartAccount = {};
+    const view = renderButtons(true, true);
+
+    fireEvent.click(view.getByTitle('Remove agreement'));
+    expect(mocks.submitResponse).toHaveBeenLastCalledWith('clear', expect.any(Object));
+
+    mocks.optimisticResponse = 'negative';
+    view.rerender(
+      <ClaimResponseBatchBoundary ready>
+        <EntityVoteButtons entityId="claim-1" spaceId="space-1" responseKind="stance" />
+      </ClaimResponseBatchBoundary>
+    );
+    fireEvent.click(view.getByTitle('Agree'));
+    expect(mocks.submitResponse).toHaveBeenLastCalledWith('positive', expect.any(Object));
+
+    mocks.optimisticResponse = 'positive';
+    view.rerender(
+      <ClaimResponseBatchBoundary ready>
+        <EntityVoteButtons entityId="claim-1" spaceId="space-1" responseKind="stance" />
+      </ClaimResponseBatchBoundary>
+    );
+    fireEvent.click(view.getByTitle('Disagree'));
+    expect(mocks.submitResponse).toHaveBeenLastCalledWith('negative', expect.any(Object));
+  });
+
+  it('renders 50 batched claims with one summary request and no individual response requests', async () => {
+    const targets = Array.from({ length: 50 }, (_, index) => ({
+      entityId: `claim-${index}`,
+      responseKind: index % 2 === 0 ? ('stance' as const) : ('veracity' as const),
+    }));
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+
+    const view = render(<BatchedClaims targets={targets} />, {
+      wrapper: ({ children }: { children: ReactNode }) => (
+        <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+      ),
+    });
+
+    await waitFor(() => expect(view.container.querySelector('.animate-pulse')).not.toBeInTheDocument());
+    expect(mocks.getSummaryPage).toHaveBeenCalledOnce();
+    expect(mocks.getCounts).not.toHaveBeenCalled();
+    expect(mocks.getViewerResponse).not.toHaveBeenCalled();
+    expect(mocks.getResponders).not.toHaveBeenCalled();
+    expect(mocks.queryEntityOptions.length).toBeGreaterThanOrEqual(50);
+    expect(mocks.queryEntityOptions.every(option => (option as { enabled: boolean }).enabled === false)).toBe(true);
+    expect(new Set(mocks.queryEntityOptions.map(option => (option as { id: string }).id)).size).toBe(50);
+  });
+});
+
+function BatchedClaims({ targets }: { targets: Array<{ entityId: string; responseKind: 'stance' | 'veracity' }> }) {
+  const batch = useClaimResponseSummaryBatch({ spaceId: 'space-1', targets, enabled: true });
+  return (
+    <ClaimResponseBatchBoundary ready={batch.isSuccess}>
+      {targets.map(target => (
+        <EntityVoteButtons
+          key={target.entityId}
+          entityId={target.entityId}
+          spaceId="space-1"
+          responseKind={target.responseKind}
+        />
+      ))}
+    </ClaimResponseBatchBoundary>
+  );
+}
+
+function renderButtons(ready: boolean, seedCaches = false, responseKind: 'stance' | 'veracity' = 'stance') {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  if (seedCaches) {
+    queryClient.setQueryData(entityResponseCountsQueryKey('claim-1', 'space-1', 0, responseKind), {
+      positive: 2,
+      negative: 1,
+    });
+    queryClient.setQueryData(
+      userEntityResponseQueryKey('profile-1', 'claim-1', 'space-1', 0, responseKind),
+      'positive'
+    );
+  }
+  return render(
+    <ClaimResponseBatchBoundary ready={ready}>
+      <EntityVoteButtons entityId="claim-1" spaceId="space-1" responseKind={responseKind} />
+    </ClaimResponseBatchBoundary>,
+    {
+      wrapper: ({ children }: { children: ReactNode }) => (
+        <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+      ),
+    }
+  );
+}
diff --git a/apps/web/partials/entity-page/entity-vote-buttons.tsx b/apps/web/partials/entity-page/entity-vote-buttons.tsx
index 03692ca99f..a068527d6a 100644
--- a/apps/web/partials/entity-page/entity-vote-buttons.tsx
+++ b/apps/web/partials/entity-page/entity-vote-buttons.tsx
@@ -1,6 +1,7 @@
 'use client';
 
 import { useGeoLogin } from '@geogenesis/auth';
+import { SystemIds } from '@geoprotocol/geo-sdk/lite';
 import * as Popover from '@radix-ui/react-popover';
 import { useQuery } from '@tanstack/react-query';
 
@@ -12,15 +13,34 @@ import { useSetAtom } from 'jotai';
 
 import { downvoted, trackPrivyAuth, upvoted, voteCast } from '~/core/analytics';
 import { CLAIM_IS_FACTUAL_PROPERTY_ID, CLAIM_TYPE_ID } from '~/core/claims/ontology';
-import { useEntityVote } from '~/core/hooks/use-entity-vote';
+import { useEntityResponse } from '~/core/hooks/use-entity-vote';
 import { useSmartAccount } from '~/core/hooks/use-smart-account';
-import { type EntityVoter, getEntityVoteCount, getEntityVoters, getUserEntityVote } from '~/core/io/queries';
+import { uuidToHex } from '~/core/id/normalize';
+import {
+  type EntityResponder,
+  getEntityResponders,
+  getEntityResponseCounts,
+  getUserEntityResponse,
+} from '~/core/io/queries';
 import { fetchProfilesBySpaceIds } from '~/core/io/subgraph/fetch-profile';
+import {
+  type ActiveResponseDirection,
+  ENTITY_RESPONSE_COPY,
+  type ResponseKind,
+  entityResponderProfilesQueryKey,
+  entityRespondersQueryKey,
+  entityResponseCountsQueryKey,
+  getEntityResponseKind,
+  hasUnpublishedClaimResponseKindEdit,
+  userEntityResponseQueryKey,
+} from '~/core/responses/entity-response';
+import { useClaimResponseBatchState } from '~/core/responses/use-claim-response-summaries';
 import { usePendingPersonalSpace } from '~/core/state/pending-personal-space';
 import { useQueryEntity } from '~/core/sync/use-store';
 import { Profile } from '~/core/types';
 
 import { Avatar } from '~/design-system/avatar';
+import { getChecked } from '~/design-system/checkbox';
 import { ChevronDown } from '~/design-system/icons/chevron-down';
 import { ChevronUp } from '~/design-system/icons/chevron-up';
 import { ThumbDown } from '~/design-system/icons/thumb-down';
@@ -29,53 +49,65 @@ import { VoteArrow } from '~/design-system/icons/vote-arrow';
 import { PrefetchLink as Link } from '~/design-system/prefetch-link';
 import { Skeleton } from '~/design-system/skeleton';
 
-import { ClaimVoterAvatars } from '~/partials/entity-page/claim-voter-avatars';
+import { ClaimResponderAvatars } from '~/partials/entity-page/claim-voter-avatars';
 import { avatarAtom, nameAtom, spaceIdAtom, stepAtom, topicIdAtom } from '~/partials/onboarding/dialog';
 
-type OptimisticVote = 0 | 1 | 'none' | null;
+const ENTITY_RESPONSE_OBJECT_TYPE = 0;
 
-// Entity votes are always object type 0 — the SDK hardcodes it in the vote
-// topic, so reads here pin the same value to stay consistent with writes.
-const ENTITY_VOTE_OBJECT_TYPE = 0;
+type ResponseVariant = 'default' | 'thumbs' | 'chevrons';
 
-type VoteVariant = 'default' | 'thumbs' | 'chevrons';
-
-const normalizeId = (id: string) => id.replace(/-/g, '').toLowerCase();
-
-const CLAIM_TYPE = normalizeId(CLAIM_TYPE_ID);
-const CLAIM_IS_FACTUAL = normalizeId(CLAIM_IS_FACTUAL_PROPERTY_ID);
-
-function parseBoolean(value: string | null | undefined): boolean {
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === '1' || normalized === 'true' || normalized === 'yes';
-}
+const CLAIM_TYPE = uuidToHex(CLAIM_TYPE_ID);
+const CLAIM_IS_FACTUAL = uuidToHex(CLAIM_IS_FACTUAL_PROPERTY_ID);
+const TYPES_PROPERTY = uuidToHex(SystemIds.TYPES_PROPERTY);
 
 type EntityVoteButtonsProps = {
   entityId: string;
   spaceId: string;
-  claimVoterAvatarsPosition?: 'leading' | 'trailing';
+  responseKind?: ResponseKind | null;
+  claimResponderAvatarsPosition?: 'leading' | 'trailing';
 };
 
 export function EntityVoteButtons({
   entityId,
   spaceId,
-  claimVoterAvatarsPosition = 'leading',
+  responseKind: responseKindOverride,
+  claimResponderAvatarsPosition = 'leading',
 }: EntityVoteButtonsProps) {
-  const { upvote, downvote, unvote, isConnected, personalSpaceId } = useEntityVote({
-    entityId,
+  const responseBatch = useClaimResponseBatchState();
+  const { entity, isLoading: isLoadingEntity } = useQueryEntity({
+    id: entityId,
     spaceId,
+    includeDeleted: true,
+    enabled: responseKindOverride === undefined,
   });
+  const activeRelations = entity?.relations.filter(relation => !relation.isDeleted) ?? [];
+  const activeValues = entity?.values.filter(value => !value.isDeleted) ?? [];
+  const isClaim =
+    activeRelations.some(
+      relation => uuidToHex(relation.type.id) === TYPES_PROPERTY && uuidToHex(relation.toEntity.id) === CLAIM_TYPE
+    ) ?? false;
+  const isFactualClaim =
+    isClaim &&
+    getChecked(
+      activeValues.find(
+        v => uuidToHex(v.spaceId) === uuidToHex(spaceId) && uuidToHex(v.property.id) === CLAIM_IS_FACTUAL
+      )?.value
+    ) === true;
+  const inferredResponseKind = getEntityResponseKind({ isClaim, isFactual: isFactualClaim });
+  const responseKind = responseKindOverride === undefined ? inferredResponseKind : responseKindOverride;
+  const hasUnpublishedResponseKindEdit =
+    responseKindOverride === undefined && hasUnpublishedClaimResponseKindEdit(entity, spaceId);
+  const queryResponseKind = responseKind ?? 'stance';
+  const isResponseKindLoading = responseKindOverride === undefined && isLoadingEntity;
+  const variant: ResponseVariant =
+    queryResponseKind === 'curation' ? 'default' : queryResponseKind === 'veracity' ? 'chevrons' : 'thumbs';
+  const responseCopy = ENTITY_RESPONSE_COPY[queryResponseKind];
+
+  const { submitResponse, optimisticResponse, isResponseIndexingDelayed, isConnected, personalSpaceId } =
+    useEntityResponse({ entityId, spaceId, responseKind });
   const { smartAccount } = useSmartAccount();
   const { isPending: isAccountSetupPending } = usePendingPersonalSpace();
 
-  // Claim entities render a different vote control.
-  const { entity, isLoading: isLoadingEntity } = useQueryEntity({ id: entityId, spaceId });
-  const isClaim = entity?.types.some(t => normalizeId(t.id) === CLAIM_TYPE) ?? false;
-  const isFactualClaim =
-    isClaim && parseBoolean(entity?.values.find(v => normalizeId(v.property.id) === CLAIM_IS_FACTUAL)?.value);
-  const variant: VoteVariant = isClaim ? (isFactualClaim ? 'chevrons' : 'thumbs') : 'default';
-
   const setName = useSetAtom(nameAtom);
   const setTopicId = useSetAtom(topicIdAtom);
   const setAvatar = useSetAtom(avatarAtom);
@@ -86,48 +118,42 @@ export function EntityVoteButtons({
     onComplete: args => trackPrivyAuth(args, { auth_flow: 'manual_login' }),
   });
 
-  const [optimisticVote, setOptimisticVote] = React.useState<OptimisticVote>(null);
-  const [optimisticScore, setOptimisticScore] = React.useState<bigint | null>(null);
-  const [votersOpen, setVotersOpen] = React.useState(false);
+  const [respondersOpen, setRespondersOpen] = React.useState(false);
 
-  const { data: voteCounts } = useQuery<{ upvotes: number; downvotes: number } | null>({
-    queryKey: ['entity-vote-count', entityId, ENTITY_VOTE_OBJECT_TYPE],
-    queryFn: () => Effect.runPromise(getEntityVoteCount(entityId, ENTITY_VOTE_OBJECT_TYPE)),
+  const { data: responseCounts } = useQuery<{ positive: number; negative: number } | null>({
+    queryKey: entityResponseCountsQueryKey(entityId, spaceId, ENTITY_RESPONSE_OBJECT_TYPE, queryResponseKind),
+    queryFn: () =>
+      Effect.runPromise(getEntityResponseCounts(entityId, spaceId, queryResponseKind, ENTITY_RESPONSE_OBJECT_TYPE)),
+    enabled: !responseBatch.managed && !isResponseKindLoading && responseKind !== null,
     staleTime: 30_000,
   });
 
-  const { data: userVoteType } = useQuery({
-    queryKey: ['user-entity-vote', personalSpaceId, entityId, spaceId, ENTITY_VOTE_OBJECT_TYPE],
+  const { data: serverResponseDirection } = useQuery({
+    queryKey: userEntityResponseQueryKey(
+      personalSpaceId,
+      entityId,
+      spaceId,
+      ENTITY_RESPONSE_OBJECT_TYPE,
+      queryResponseKind
+    ),
     queryFn: async () => {
       if (!personalSpaceId) return null;
-      return Effect.runPromise(getUserEntityVote(personalSpaceId, entityId, spaceId, ENTITY_VOTE_OBJECT_TYPE));
+      return Effect.runPromise(
+        getUserEntityResponse(personalSpaceId, entityId, spaceId, queryResponseKind, ENTITY_RESPONSE_OBJECT_TYPE)
+      );
     },
-    enabled: !!personalSpaceId,
+    enabled: !responseBatch.managed && !!personalSpaceId && !isResponseKindLoading && responseKind !== null,
     staleTime: 30_000,
   });
 
-  React.useEffect(
-    function clearOptimisticScoreOnServerUpdate() {
-      setOptimisticScore(null);
-    },
-    [voteCounts]
-  );
+  const activeResponse = optimisticResponse === undefined ? serverResponseDirection : optimisticResponse;
 
-  React.useEffect(
-    function clearOptimisticVoteOnServerUpdate() {
-      setOptimisticVote(null);
-    },
-    [userVoteType]
-  );
-
-  const serverVoteDirection = userVoteType === 0 ? 0 : userVoteType === 1 ? 1 : null;
-  const activeVote =
-    optimisticVote !== null ? (optimisticVote === 'none' ? null : optimisticVote) : serverVoteDirection;
-
-  const upvotes = BigInt(voteCounts?.upvotes ?? 0);
-  const downvotes = BigInt(voteCounts?.downvotes ?? 0);
-  const netScore = upvotes - downvotes;
-  const displayScore = optimisticScore !== null ? optimisticScore : netScore;
+  const positiveResponses = BigInt(responseCounts?.positive ?? 0);
+  const negativeResponses = BigInt(responseCounts?.negative ?? 0);
+  const netScore = positiveResponses - negativeResponses;
+  const responseScore = (direction: ActiveResponseDirection | null | undefined) =>
+    direction === 'positive' ? 1n : direction === 'negative' ? -1n : 0n;
+  const displayScore = netScore + responseScore(activeResponse) - responseScore(serverResponseDirection);
 
   function openPrivySignIn() {
     setName('');
@@ -138,73 +164,55 @@ export function EntityVoteButtons({
     login();
   }
 
-  function handleUpvote() {
+  function handlePositiveResponse() {
     if (!smartAccount) {
       openPrivySignIn();
       return;
     }
     if (!isConnected) return;
-    const base = optimisticScore !== null ? optimisticScore : netScore;
-    if (activeVote === 0) {
-      setOptimisticVote('none');
-      setOptimisticScore(base - 1n);
-      unvote(undefined, {
+    if (activeResponse === 'positive') {
+      submitResponse('clear', {
         onSuccess: () => {
           voteCast('none', voteProperties('remove', 'up'));
         },
-        onError: () => {
-          setOptimisticVote(0);
-          setOptimisticScore(null);
-        },
       });
     } else {
-      const delta = activeVote === 1 ? 2n : 1n;
-      const prevVote = activeVote;
-      setOptimisticVote(0);
-      setOptimisticScore(base + delta);
-      upvote(undefined, {
+      const previousResponse = activeResponse ?? null;
+      submitResponse('positive', {
         onSuccess: () => {
-          upvoted(voteProperties(prevVote === 1 ? 'switch' : 'cast', prevVote === 1 ? 'down' : undefined));
-        },
-        onError: () => {
-          setOptimisticVote(prevVote === 1 ? 1 : null);
-          setOptimisticScore(null);
+          upvoted(
+            voteProperties(
+              previousResponse === 'negative' ? 'switch' : 'cast',
+              previousResponse === 'negative' ? 'down' : undefined
+            )
+          );
         },
       });
     }
   }
 
-  function handleDownvote() {
+  function handleNegativeResponse() {
     if (!smartAccount) {
       openPrivySignIn();
       return;
     }
     if (!isConnected) return;
-    const base = optimisticScore !== null ? optimisticScore : netScore;
-    if (activeVote === 1) {
-      setOptimisticVote('none');
-      setOptimisticScore(base + 1n);
-      unvote(undefined, {
+    if (activeResponse === 'negative') {
+      submitResponse('clear', {
         onSuccess: () => {
           voteCast('none', voteProperties('remove', 'down'));
         },
-        onError: () => {
-          setOptimisticVote(1);
-          setOptimisticScore(null);
-        },
       });
     } else {
-      const delta = activeVote === 0 ? 2n : 1n;
-      const prevVote = activeVote;
-      setOptimisticVote(1);
-      setOptimisticScore(base - delta);
-      downvote(undefined, {
+      const previousResponse = activeResponse ?? null;
+      submitResponse('negative', {
         onSuccess: () => {
-          downvoted(voteProperties(prevVote === 0 ? 'switch' : 'cast', prevVote === 0 ? 'up' : undefined));
-        },
-        onError: () => {
-          setOptimisticVote(prevVote === 0 ? 0 : null);
-          setOptimisticScore(null);
+          downvoted(
+            voteProperties(
+              previousResponse === 'positive' ? 'switch' : 'cast',
+              previousResponse === 'positive' ? 'up' : undefined
+            )
+          );
         },
       });
     }
@@ -216,29 +224,30 @@ export function EntityVoteButtons({
       previous_vote_direction: previousDirection,
       entity_id: entityId,
       space_id: spaceId,
-      object_type: ENTITY_VOTE_OBJECT_TYPE,
+      object_type: ENTITY_RESPONSE_OBJECT_TYPE,
     };
   }
 
   const scoreLabel = formatScore(displayScore);
 
-  const upvoteActive = activeVote === 0;
-  const downvoteActive = activeVote === 1;
+  const positiveActive = activeResponse === 'positive';
+  const negativeActive = activeResponse === 'negative';
 
-  const totalVoters = (voteCounts?.upvotes ?? 0) + (voteCounts?.downvotes ?? 0);
+  const totalResponders = (responseCounts?.positive ?? 0) + (responseCounts?.negative ?? 0);
 
-  const optimisticUpDelta = optimisticVote !== null ? (upvoteActive ? 1 : 0) - (serverVoteDirection === 0 ? 1 : 0) : 0;
-  const optimisticDownDelta =
-    optimisticVote !== null ? (downvoteActive ? 1 : 0) - (serverVoteDirection === 1 ? 1 : 0) : 0;
-  const effectiveUpvotes = Math.max(0, (voteCounts?.upvotes ?? 0) + optimisticUpDelta);
-  const effectiveDownvotes = Math.max(0, (voteCounts?.downvotes ?? 0) + optimisticDownDelta);
-  const effectiveTotal = effectiveUpvotes + effectiveDownvotes;
-  const percentLabel = effectiveTotal > 0 ? `${Math.round((100 * effectiveUpvotes) / effectiveTotal)}%` : '0%';
+  const optimisticPositiveDelta =
+    optimisticResponse !== undefined ? (positiveActive ? 1 : 0) - (serverResponseDirection === 'positive' ? 1 : 0) : 0;
+  const optimisticNegativeDelta =
+    optimisticResponse !== undefined ? (negativeActive ? 1 : 0) - (serverResponseDirection === 'negative' ? 1 : 0) : 0;
+  const effectivePositive = Math.max(0, (responseCounts?.positive ?? 0) + optimisticPositiveDelta);
+  const effectiveNegative = Math.max(0, (responseCounts?.negative ?? 0) + optimisticNegativeDelta);
+  const effectiveTotal = effectivePositive + effectiveNegative;
+  const percentLabel = effectiveTotal > 0 ? `${Math.round((100 * effectivePositive) / effectiveTotal)}%` : '0%';
 
   const isClaimVariant = variant !== 'default';
   const displayLabel = isClaimVariant ? percentLabel : scoreLabel;
 
-  const renderVoteIcon = (direction: 'up' | 'down', active: boolean) => {
+  const renderResponseIcon = (direction: 'up' | 'down', active: boolean) => {
     if (variant === 'chevrons') {
       return direction === 'up' ? <ChevronUp /> : <ChevronDown />;
     }
@@ -250,62 +259,81 @@ export function EntityVoteButtons({
     return <VoteArrow direction={direction} filled={active} color="grey-03" />;
   };
 
-  const claimVoteButtonColor = (active: boolean) => {
+  const claimResponseButtonColor = (active: boolean) => {
     if (variant === 'chevrons') {
       return active ? 'text-[#2A2B2E]' : 'text-grey-03 hover:text-grey-04';
     }
     return isClaimVariant && (active ? 'text-grey-04' : 'text-grey-03 hover:text-grey-04');
   };
 
-  const claimVoterAvatars = isClaimVariant ? (
-    <ClaimVoterAvatars
+  const claimResponderAvatars = isClaimVariant ? (
+    <ClaimResponderAvatars
       entityId={entityId}
       spaceId={spaceId}
-      objectType={ENTITY_VOTE_OBJECT_TYPE}
-      totalVoters={totalVoters}
+      objectType={ENTITY_RESPONSE_OBJECT_TYPE}
+      responseKind={queryResponseKind}
+      totalResponders={effectiveTotal}
+      viewerSpaceId={personalSpaceId}
+      optimisticViewerResponse={optimisticResponse}
     />
   ) : null;
 
-  const claimVoterAvatarsClassName = 'inline-flex h-5 shrink-0 items-center';
+  const claimResponderAvatarsClassName = 'inline-flex h-5 shrink-0 items-center';
 
-  if (isLoadingEntity) {
+  if ((responseBatch.managed && !responseBatch.ready) || isResponseKindLoading) {
     return <Skeleton className="h-5 w-16 shrink-0 rounded" />;
   }
 
+  if (hasUnpublishedResponseKindEdit) {
+    return (
+      <span className="text-metadata text-grey-04" title="Publish the claim type change before responding">
+        Publish changes before responding
+      </span>
+    );
+  }
+
+  if (responseKind === null) {
+    return (
+      <span className="text-metadata text-grey-04" title="The response type is unavailable">
+        Response unavailable
+      </span>
+    );
+  }
+
   return (
     <div className="flex items-center gap-1 text-metadataMedium text-text">
-      {claimVoterAvatarsPosition === 'leading' && claimVoterAvatars ? (
-        <span className={cx(claimVoterAvatarsClassName, 'mr-1')}>{claimVoterAvatars}</span>
+      {claimResponderAvatarsPosition === 'leading' && claimResponderAvatars ? (
+        <span className={cx(claimResponderAvatarsClassName, 'mr-1')}>{claimResponderAvatars}</span>
       ) : null}
       <button
-        onClick={handleUpvote}
+        onClick={handlePositiveResponse}
         disabled={!!smartAccount && (!isConnected || isAccountSetupPending)}
         title={
           !smartAccount
-            ? 'Sign in to vote'
+            ? responseCopy.signIn
             : isAccountSetupPending
               ? 'Finishing account setup…'
               : isConnected
-                ? upvoteActive
-                  ? 'Remove upvote'
-                  : 'Upvote'
-                : 'Connect wallet to vote'
+                ? positiveActive
+                  ? responseCopy.removePositive
+                  : responseCopy.positiveAction
+                : responseCopy.connect
         }
         className={cx(
           'group/vote flex h-5 w-5 items-center justify-center rounded transition-colors',
           !isClaimVariant && 'translate-y-px',
-          claimVoteButtonColor(upvoteActive),
+          claimResponseButtonColor(positiveActive),
           !!smartAccount && (!isConnected || isAccountSetupPending) && 'cursor-default opacity-50'
         )}
       >
-        {renderVoteIcon('up', upvoteActive)}
+        {renderResponseIcon('up', positiveActive)}
       </button>
-      <Popover.Root open={votersOpen} onOpenChange={setVotersOpen}>
+      <Popover.Root open={respondersOpen} onOpenChange={setRespondersOpen}>
         <Popover.Trigger asChild>
           <button
             className="min-w-[2ch] cursor-pointer text-center text-[16px]! leading-5 tabular-nums hover:text-grey-04"
-            title={totalVoters > 0 ? 'View voters' : undefined}
-            disabled={totalVoters === 0}
+            title={totalResponders > 0 ? responseCopy.viewResponders : undefined}
+            disabled={totalResponders === 0}
           >
             {displayLabel}
           </button>
@@ -317,86 +345,118 @@ export function EntityVoteButtons({
             sideOffset={8}
             className="z-100 w-[200px] overflow-hidden rounded-lg border border-grey-02 bg-white shadow-lg"
           >
-            <VotersPopoverContent entityId={entityId} spaceId={spaceId} objectType={ENTITY_VOTE_OBJECT_TYPE} />
+            <RespondersPopoverContent
+              entityId={entityId}
+              spaceId={spaceId}
+              objectType={ENTITY_RESPONSE_OBJECT_TYPE}
+              responseKind={responseKind}
+            />
           </Popover.Content>
         </Popover.Portal>
       </Popover.Root>
       <button
-        onClick={handleDownvote}
+        onClick={handleNegativeResponse}
         disabled={!!smartAccount && (!isConnected || isAccountSetupPending)}
         title={
           !smartAccount
-            ? 'Sign in to vote'
+            ? responseCopy.signIn
             : isAccountSetupPending
               ? 'Finishing account setup…'
               : isConnected
-                ? downvoteActive
-                  ? 'Remove downvote'
-                  : 'Downvote'
-                : 'Connect wallet to vote'
+                ? negativeActive
+                  ? responseCopy.removeNegative
+                  : responseCopy.negativeAction
+                : responseCopy.connect
         }
         className={cx(
           'group/vote flex h-5 w-5 items-center justify-center rounded transition-colors',
           !isClaimVariant && 'translate-y-px',
-          claimVoteButtonColor(downvoteActive),
+          claimResponseButtonColor(negativeActive),
           !!smartAccount && (!isConnected || isAccountSetupPending) && 'cursor-default opacity-50'
         )}
       >
-        {renderVoteIcon('down', downvoteActive)}
+        {renderResponseIcon('down', negativeActive)}
       </button>
-      {claimVoterAvatarsPosition === 'trailing' && claimVoterAvatars ? (
-        <span className={cx(claimVoterAvatarsClassName, 'ml-1')}>{claimVoterAvatars}</span>
+      {claimResponderAvatarsPosition === 'trailing' && claimResponderAvatars ? (
+        <span className={cx(claimResponderAvatarsClassName, 'ml-1')}>{claimResponderAvatars}</span>
+      ) : null}
+      {isResponseIndexingDelayed ? (
+        <span aria-live="polite" className="ml-1 text-metadata text-grey-04">
+          Response submitted. Waiting for confirmation.
+        </span>
       ) : null}
     </div>
   );
 }
 
-type VoterWithProfile = EntityVoter & { profile: Profile };
+type ResponderWithProfile = EntityResponder & { profile: Profile };
 
-function VotersPopoverContent({
+function RespondersPopoverContent({
   entityId,
   spaceId,
   objectType,
+  responseKind,
 }: {
   entityId: string;
   spaceId: string;
   objectType: 0 | 1;
+  responseKind: ResponseKind;
 }) {
-  const { data: votersWithProfiles, isLoading } = useQuery({
-    queryKey: ['entity-voters', entityId, spaceId, objectType],
-    queryFn: async () => {
-      const voters = await Effect.runPromise(getEntityVoters(entityId, spaceId, objectType));
-      if (voters.length === 0) return [];
-      const profiles = await Effect.runPromise(fetchProfilesBySpaceIds(voters.map(v => v.userId)));
-      return voters.map((voter, i): VoterWithProfile => ({ ...voter, profile: profiles[i]! }));
-    },
+  const responseBatch = useClaimResponseBatchState();
+  const copy = ENTITY_RESPONSE_COPY[responseKind];
+  const respondersQueryKey = entityRespondersQueryKey(entityId, spaceId, objectType, responseKind);
+  const { data: responders, isLoading: isLoadingResponders } = useQuery({
+    queryKey: respondersQueryKey,
+    queryFn: () => Effect.runPromise(getEntityResponders(entityId, spaceId, responseKind, objectType)),
+    enabled: !responseBatch.managed,
     staleTime: 30_000,
   });
+  const responderSpaceIds = React.useMemo(() => responders?.map(responder => responder.userId) ?? [], [responders]);
+  const { data: profiles, isLoading: isLoadingProfiles } = useQuery({
+    queryKey: [...entityResponderProfilesQueryKey(entityId, spaceId, objectType, responseKind), responderSpaceIds],
+    enabled: !responseBatch.managed && responderSpaceIds.length > 0,
+    queryFn: () => Effect.runPromise(fetchProfilesBySpaceIds(responderSpaceIds)),
+    staleTime: 30_000,
+  });
+  let respondersWithProfiles: ResponderWithProfile[] | undefined;
+  if (responders?.length === 0) {
+    respondersWithProfiles = [];
+  } else if (responders && profiles) {
+    respondersWithProfiles = responders.map((responder, index): ResponderWithProfile => ({
+      ...responder,
+      profile: profiles[index]!,
+    }));
+  }
+  const isLoading = isLoadingResponders || (responderSpaceIds.length > 0 && isLoadingProfiles);
 
-  const upvoters = votersWithProfiles?.filter(v => v.voteType === 0) ?? [];
-  const downvoters = votersWithProfiles?.filter(v => v.voteType === 1) ?? [];
+  const positiveResponders = respondersWithProfiles?.filter(v => v.direction === 'positive') ?? [];
+  const negativeResponders = respondersWithProfiles?.filter(v => v.direction === 'negative') ?? [];
 
   if (isLoading) {
-    return <div className="px-3 py-4 text-center text-metadataMedium text-grey-04">Loading voters...</div>;
+    return <div className="px-3 py-4 text-center text-metadataMedium text-grey-04">{copy.loading}</div>;
   }
 
-  if (!votersWithProfiles || votersWithProfiles.length === 0) {
-    return <div className="px-3 py-4 text-center text-metadataMedium text-grey-04">No votes yet</div>;
+  if (!respondersWithProfiles || respondersWithProfiles.length === 0) {
+    return <div className="px-3 py-4 text-center text-metadataMedium text-grey-04">{copy.empty}</div>;
   }
 
   return (
     <div className="max-h-[356px] overflow-y-auto">
-      {upvoters.length > 0 && <VoterSection label="Upvotes" voters={upvoters} />}
-      {downvoters.length > 0 && <VoterSection label="Downvotes" voters={downvoters} />}
+      {positiveResponders.length > 0 && (
+        <ResponderSection label={copy.positiveSection} responders={positiveResponders} />
+      )}
+      {negativeResponders.length > 0 && (
+        <ResponderSection label={copy.negativeSection} responders={negativeResponders} />
+      )}
     </div>
   );
 }
 
-function VoterSection({ label, voters }: { label: string; voters: VoterWithProfile[] }) {
+function ResponderSection({ label, responders }: { label: string; responders: ResponderWithProfile[] }) {
   return (
     <div>
       <div className="px-3 pt-2.5 pb-1.5 text-footnoteMedium text-grey-04">{label}</div>
-      {voters.map(v => (
+      {responders.map(v => (
         <VoterRow key={v.userId} profile={v.profile} />
       ))}
     </div>
diff --git a/apps/web/partials/explore/explore-feed-card.tsx b/apps/web/partials/explore/explore-feed-card.tsx
index 477e441219..75f783aacf 100644
--- a/apps/web/partials/explore/explore-feed-card.tsx
+++ b/apps/web/partials/explore/explore-feed-card.tsx
@@ -116,7 +116,7 @@ export function ExploreFeedCard({ item, hideSpaceLink = false, hideJoinButton =
       </div>
 
       <div className="flex items-center gap-6">
-        <EntityVoteButtons entityId={item.entityId} spaceId={item.spaceId} claimVoterAvatarsPosition="trailing" />
+        <EntityVoteButtons entityId={item.entityId} spaceId={item.spaceId} claimResponderAvatarsPosition="trailing" />
         <Link
           href={entityHref}
           className="inline-flex items-center gap-1.5 text-grey-04 transition-colors hover:text-text"