@genspectrum/dashboard-components 0.6.12 → 0.6.14

package/src/query/queryMutationsOverTime.spec.ts

@@ -8,15 +8,44 @@ describe('queryMutationsOverTime', () => {
         const lapisFilter = { field1: 'value1', field2: 'value2' };
         const dateField = 'dateField';
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-01',
+                    dateFieldTo: '2023-01-01',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-03',
+                    dateFieldTo: '2023-01-03',
+                    fields: [],
+                },
+                response: { data: [{ count: 13 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -53,16 +82,16 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
-                { proportion: 0.1, count: 1 },
-                { proportion: 0.2, count: 2 },
-                { proportion: 0.3, count: 3 },
+                { proportion: 0.1, count: 1, totalCount: 11 },
+                { proportion: 0.2, count: 2, totalCount: 12 },
+                { proportion: 0.3, count: 3, totalCount: 13 },
             ],
             [
-                { proportion: 0.4, count: 4 },
-                { proportion: 0, count: 0 },
-                { proportion: 0, count: 0 },
+                { proportion: 0.4, count: 4, totalCount: 11 },
+                { proportion: 0, count: 0, totalCount: 0 },
+                { proportion: 0, count: 0, totalCount: 0 },
             ],
         ]);
 
@@ -80,15 +109,44 @@ describe('queryMutationsOverTime', () => {
         const lapisFilter = { field1: 'value1', field2: 'value2' };
         const dateField = 'dateField';
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
+            {
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
+            },
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-01',
+                    dateFieldTo: '2023-01-01',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-03',
+                    dateFieldTo: '2023-01-03',
+                    fields: [],
+                },
+                response: { data: [{ count: 13 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -125,16 +183,16 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
-                { proportion: 0.1, count: 1 },
-                { proportion: 0.3, count: 3 },
-                { proportion: 0, count: 0 },
+                { proportion: 0.1, count: 1, totalCount: 11 },
+                { proportion: 0.3, count: 3, totalCount: 13 },
+                { proportion: 0, count: 0, totalCount: 0 },
             ],
             [
-                { proportion: 0.4, count: 4 },
-                { proportion: 0, count: 0 },
-                { proportion: 0, count: 0 },
+                { proportion: 0.4, count: 4, totalCount: 11 },
+                { proportion: 0, count: 0, totalCount: 0 },
+                { proportion: 0, count: 0, totalCount: 0 },
             ],
         ]);
 
@@ -152,15 +210,44 @@ describe('queryMutationsOverTime', () => {
         const lapisFilter = { field1: 'value1', field2: 'value2' };
         const dateField = 'dateField';
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
+            {
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
+            },
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-01',
+                    dateFieldTo: '2023-01-01',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-03',
+                    dateFieldTo: '2023-01-03',
+                    fields: [],
+                },
+                response: { data: [{ count: 13 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -197,7 +284,7 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([]);
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([]);
         expect(result.getFirstAxisKeys()).to.deep.equal([]);
         expect(result.getSecondAxisKeys()).to.deep.equal([]);
     });
@@ -206,15 +293,35 @@ describe('queryMutationsOverTime', () => {
         const dateField = 'dateField';
         const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}From`]: '2023-01-02' };
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
+            {
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
+            },
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-03',
+                    dateFieldTo: '2023-01-03',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -242,10 +349,10 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
-                { proportion: 0.2, count: 2 },
-                { proportion: 0.3, count: 3 },
+                { proportion: 0.2, count: 2, totalCount: 11 },
+                { proportion: 0.3, count: 3, totalCount: 12 },
             ],
         ]);
 
@@ -261,15 +368,35 @@ describe('queryMutationsOverTime', () => {
         const dateField = 'dateField';
         const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}To`]: '2023-01-02' };
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-01',
+                    dateFieldTo: '2023-01-01',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -297,10 +424,10 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
-                { proportion: 0.1, count: 1 },
-                { proportion: 0.2, count: 2 },
+                { proportion: 0.1, count: 1, totalCount: 11 },
+                { proportion: 0.2, count: 2, totalCount: 12 },
             ],
         ]);
 
@@ -316,15 +443,26 @@ describe('queryMutationsOverTime', () => {
         const dateField = 'dateField';
         const lapisFilter = { field1: 'value1', field2: 'value2', [dateField]: '2023-01-02' };
 
-        lapisRequestMocks.aggregated(
-            { ...lapisFilter, fields: [dateField] },
+        lapisRequestMocks.multipleAggregated([
             {
-                data: [
-                    { count: 1, [dateField]: '2023-01-01' },
-                    { count: 2, [dateField]: '2023-01-03' },
-                ],
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-01' },
+                        { count: 2, [dateField]: '2023-01-03' },
+                    ],
+                },
             },
-        );
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-02',
+                    dateFieldTo: '2023-01-02',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
+            },
+        ]);
 
         lapisRequestMocks.multipleMutations(
             [
@@ -343,7 +481,15 @@ describe('queryMutationsOverTime', () => {
 
         const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
 
-        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([[{ proportion: 0.2, count: 2 }]]);
+        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+            [
+                {
+                    proportion: 0.2,
+                    count: 2,
+                    totalCount: 11,
+                },
+            ],
+        ]);
 
         const sequences = result.getFirstAxisKeys();
         expect(sequences[0].code).toBe('sequenceName:A123T');

package/src/query/queryMutationsOverTime.ts

@@ -25,9 +25,10 @@ import {
 export type MutationOverTimeData = {
     date: Temporal;
     mutations: SubstitutionOrDeletionEntry[];
+    totalCount: number;
 };
 
-export type MutationOverTimeMutationValue = { proportion: number; count: number };
+export type MutationOverTimeMutationValue = { proportion: number; count: number; totalCount: number };
 export type MutationOverTimeDataGroupedByMutation = Map2d<
     Substitution | Deletion,
     Temporal,
@@ -75,9 +76,11 @@ export async function queryMutationsOverTimeData(
         };
 
         const data = await fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
+        const totalCountQuery = await getTotalNumberOfSequencesInDateRange(filter).evaluate(lapis, signal);
         return {
             date,
             mutations: data.content,
+            totalCount: totalCountQuery.content[0].count,
         };
     });
 
@@ -164,6 +167,7 @@ export function groupByMutation(data: MutationOverTimeData[]) {
             dataArray.set(mutationEntry.mutation, mutationData.date, {
                 count: mutationEntry.count,
                 proportion: mutationEntry.proportion,
+                totalCount: mutationData.totalCount,
             });
         });
     });
@@ -181,8 +185,12 @@ function addZeroValuesForDatesWithNoMutationData(
         const someMutation = dataArray.getFirstAxisKeys()[0];
         data.forEach((mutationData) => {
             if (mutationData.mutations.length === 0) {
-                dataArray.set(someMutation, mutationData.date, { count: 0, proportion: 0 });
+                dataArray.set(someMutation, mutationData.date, { count: 0, proportion: 0, totalCount: 0 });
             }
         });
     }
 }
+
+function getTotalNumberOfSequencesInDateRange(filter: LapisFilter) {
+    return new FetchAggregatedOperator<{ count: number }>(filter);
+}

package/src/web-components/input/gs-date-range-selector.tsx

@@ -1,7 +1,6 @@
 import { customElement, property } from 'lit/decorators.js';
 
-import { DateRangeSelector } from '../../preact/dateRangeSelector/date-range-selector';
-import { type CustomSelectOption, type PresetOptionValues } from '../../preact/dateRangeSelector/selectableOptions';
+import { DateRangeSelector, type DateRangeSelectorProps } from '../../preact/dateRangeSelector/date-range-selector';
 import { type Equals, type Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapter } from '../PreactLitAdapter';
 
@@ -129,9 +128,30 @@ declare global {
 
 /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */
 type CustomSelectOptionsMatches = Expect<
-    Equals<typeof DateRangeSelectorComponent.prototype.customSelectOptions, CustomSelectOption<string>[]>
+    Equals<
+        typeof DateRangeSelectorComponent.prototype.customSelectOptions,
+        DateRangeSelectorProps<string>['customSelectOptions']
+    >
+>;
+type EarliestDateMatches = Expect<
+    Equals<typeof DateRangeSelectorComponent.prototype.earliestDate, DateRangeSelectorProps<string>['earliestDate']>
 >;
 type InitialValueMatches = Expect<
-    Equals<typeof DateRangeSelectorComponent.prototype.initialValue, PresetOptionValues | string>
+    Equals<typeof DateRangeSelectorComponent.prototype.initialValue, DateRangeSelectorProps<string>['initialValue']>
+>;
+type InitialDateFromMatches = Expect<
+    Equals<
+        typeof DateRangeSelectorComponent.prototype.initialDateFrom,
+        DateRangeSelectorProps<string>['initialDateFrom']
+    >
+>;
+type InitialDateToMatches = Expect<
+    Equals<typeof DateRangeSelectorComponent.prototype.initialDateTo, DateRangeSelectorProps<string>['initialDateTo']>
+>;
+type WidthMatches = Expect<
+    Equals<typeof DateRangeSelectorComponent.prototype.width, DateRangeSelectorProps<string>['width']>
+>;
+type DateColumnMatches = Expect<
+    Equals<typeof DateRangeSelectorComponent.prototype.dateColumn, DateRangeSelectorProps<string>['dateColumn']>
 >;
 /* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/input/gs-lineage-filter.tsx

@@ -1,6 +1,7 @@
 import { customElement, property } from 'lit/decorators.js';
 
-import { LineageFilter } from '../../preact/lineageFilter/lineage-filter';
+import { LineageFilter, type LineageFilterProps } from '../../preact/lineageFilter/lineage-filter';
+import type { Equals, Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapter } from '../PreactLitAdapter';
 
 /**
@@ -77,3 +78,16 @@ declare global {
         'gs-lineage-filter-changed': CustomEvent<Record<string, string>>;
     }
 }
+
+/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */
+type InitialValueMatches = Expect<
+    Equals<typeof LineageFilterComponent.prototype.initialValue, LineageFilterProps['initialValue']>
+>;
+type LapisFieldMatches = Expect<
+    Equals<typeof LineageFilterComponent.prototype.lapisField, LineageFilterProps['lapisField']>
+>;
+type PlaceholderTextMatches = Expect<
+    Equals<typeof LineageFilterComponent.prototype.placeholderText, LineageFilterProps['placeholderText']>
+>;
+type WidthMatches = Expect<Equals<typeof LineageFilterComponent.prototype.width, LineageFilterProps['width']>>;
+/* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/input/gs-location-filter.tsx

@@ -1,6 +1,7 @@
 import { customElement, property } from 'lit/decorators.js';
 
-import { LocationFilter } from '../../preact/locationFilter/location-filter';
+import { LocationFilter, type LocationFilterProps } from '../../preact/locationFilter/location-filter';
+import type { Equals, Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapter } from '../PreactLitAdapter';
 
 /**
@@ -86,3 +87,14 @@ declare global {
         'gs-location-changed': CustomEvent<Record<string, string>>;
     }
 }
+
+/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */
+type InitialValueMatches = Expect<
+    Equals<typeof LocationFilterComponent.prototype.initialValue, LocationFilterProps['initialValue']>
+>;
+type FieldsMatches = Expect<Equals<typeof LocationFilterComponent.prototype.fields, LocationFilterProps['fields']>>;
+type PlaceholderTextMatches = Expect<
+    Equals<typeof LocationFilterComponent.prototype.placeholderText, LocationFilterProps['placeholderText']>
+>;
+type WidthMatches = Expect<Equals<typeof LocationFilterComponent.prototype.width, LocationFilterProps['width']>>;
+/* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/input/gs-mutation-filter.tsx

@@ -115,4 +115,5 @@ declare global {
 type InitialValueMatches = Expect<
     Equals<typeof MutationFilterComponent.prototype.initialValue, MutationFilterProps['initialValue']>
 >;
+type WidthMatches = Expect<Equals<typeof MutationFilterComponent.prototype.width, MutationFilterProps['width']>>;
 /* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/input/gs-text-input.tsx

@@ -1,6 +1,7 @@
 import { customElement, property } from 'lit/decorators.js';
 
-import { TextInput } from '../../preact/textInput/text-input';
+import { TextInput, type TextInputProps } from '../../preact/textInput/text-input';
+import type { Equals, Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapter } from '../PreactLitAdapter';
 
 /**
@@ -71,3 +72,14 @@ declare global {
         'gs-text-input-changed': CustomEvent<Record<string, string>>;
     }
 }
+
+/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */
+type InitialValueMatches = Expect<
+    Equals<typeof TextInputComponent.prototype.initialValue, TextInputProps['initialValue']>
+>;
+type LapisFieldMatches = Expect<Equals<typeof TextInputComponent.prototype.lapisField, TextInputProps['lapisField']>>;
+type PlaceholderTextMatches = Expect<
+    Equals<typeof TextInputComponent.prototype.placeholderText, TextInputProps['placeholderText']>
+>;
+type WidthMatches = Expect<Equals<typeof TextInputComponent.prototype.width, TextInputProps['width']>>;
+/* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/visualization/gs-aggregate.tsx

@@ -1,7 +1,8 @@
 import { customElement, property } from 'lit/decorators.js';
 
-import { Aggregate, type View } from '../../preact/aggregatedData/aggregate';
+import { Aggregate, type AggregateProps, type View } from '../../preact/aggregatedData/aggregate';
 import { type LapisFilter } from '../../types';
+import { type Equals, type Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapterWithGridJsStyles } from '../PreactLitAdapterWithGridJsStyles';
 
 /**
@@ -102,3 +103,18 @@ declare global {
         'gs-aggregate-component': AggregateComponent;
     }
 }
+
+/* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars */
+type FieldsMatches = Expect<Equals<typeof AggregateComponent.prototype.fields, AggregateProps['fields']>>;
+type ViewsMatches = Expect<Equals<typeof AggregateComponent.prototype.views, AggregateProps['views']>>;
+type FilterMatches = Expect<Equals<typeof AggregateComponent.prototype.filter, AggregateProps['filter']>>;
+type WidthMatches = Expect<Equals<typeof AggregateComponent.prototype.width, AggregateProps['width']>>;
+type HeightMatches = Expect<Equals<typeof AggregateComponent.prototype.height, AggregateProps['height']>>;
+type InitialSortFieldMatches = Expect<
+    Equals<typeof AggregateComponent.prototype.initialSortField, AggregateProps['initialSortField']>
+>;
+type InitialSortDirectionMatches = Expect<
+    Equals<typeof AggregateComponent.prototype.initialSortDirection, AggregateProps['initialSortDirection']>
+>;
+type PageSizeMatches = Expect<Equals<typeof AggregateComponent.prototype.pageSize, AggregateProps['pageSize']>>;
+/* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */

package/src/web-components/visualization/gs-mutation-comparison.tsx

@@ -112,4 +112,13 @@ type SequenceTypeMatches = Expect<
 type ViewsMatches = Expect<
     Equals<typeof MutationComparisonComponent.prototype.views, MutationComparisonProps['views']>
 >;
+type WidthMatches = Expect<
+    Equals<typeof MutationComparisonComponent.prototype.width, MutationComparisonProps['width']>
+>;
+type HeightMatches = Expect<
+    Equals<typeof MutationComparisonComponent.prototype.height, MutationComparisonProps['height']>
+>;
+type PageSizeMatches = Expect<
+    Equals<typeof MutationComparisonComponent.prototype.pageSize, MutationComparisonProps['pageSize']>
+>;
 /* eslint-enable @typescript-eslint/no-unused-vars, no-unused-vars */