@gen-epix/ui-casedb 2.0.0 → 2.0.1

package/dist/index.d.ts

@@ -1 +1,2412 @@
+import { AnyObject } from 'yup';
+import { AutoCompleteOption } from '@gen-epix/ui';
+import { CaseDbApiPermission } from '@gen-epix/api-casedb';
+import { CaseDbCase } from '@gen-epix/api-casedb';
+import { CaseDbCaseBatchUploadResult } from '@gen-epix/api-casedb';
+import { CaseDbCaseDataCollectionLink } from '@gen-epix/api-casedb';
+import { CaseDbCaseForUpload } from '@gen-epix/api-casedb';
+import { CaseDbCaseRights } from '@gen-epix/api-casedb';
+import { CaseDbCaseSet } from '@gen-epix/api-casedb';
+import { CaseDbCaseSetCategory } from '@gen-epix/api-casedb';
+import { CaseDbCaseSetDataCollectionLink } from '@gen-epix/api-casedb';
+import { CaseDbCaseSetRights } from '@gen-epix/api-casedb';
+import { CaseDbCaseSetStatus } from '@gen-epix/api-casedb';
+import { CaseDbCaseStats } from '@gen-epix/api-casedb';
+import { CaseDbCaseType } from '@gen-epix/api-casedb';
+import { CaseDbCaseTypeAccessAbac } from '@gen-epix/api-casedb';
+import { CaseDbCaseTypeSet } from '@gen-epix/api-casedb';
+import { CaseDbCaseTypeSetCategory } from '@gen-epix/api-casedb';
+import { CaseDbCaseTypeSetCategoryPurpose } from '@gen-epix/api-casedb';
+import { CaseDbCaseTypeSetMember } from '@gen-epix/api-casedb';
+import { CaseDbCaseUploadResult } from '@gen-epix/api-casedb';
+import { CaseDbCol } from '@gen-epix/api-casedb';
+import { CaseDbColSet } from '@gen-epix/api-casedb';
+import { CaseDbColSetMember } from '@gen-epix/api-casedb';
+import { CaseDbColType } from '@gen-epix/api-casedb';
+import { CaseDbCompleteCaseType } from '@gen-epix/api-casedb';
+import { CaseDbConcept } from '@gen-epix/api-casedb';
+import { CaseDbConceptRelationType } from '@gen-epix/api-casedb';
+import { CaseDbConceptSet } from '@gen-epix/api-casedb';
+import { CaseDbConceptSetType } from '@gen-epix/api-casedb';
+import { CaseDbDataCollection } from '@gen-epix/api-casedb';
+import { CaseDbDataCollectionSetMember } from '@gen-epix/api-casedb';
+import { CaseDbDim } from '@gen-epix/api-casedb';
+import { CaseDbDimType } from '@gen-epix/api-casedb';
+import { CaseDbDisease } from '@gen-epix/api-casedb';
+import { CaseDbEtiologicalAgent } from '@gen-epix/api-casedb';
+import { CaseDbFileCompression } from '@gen-epix/api-casedb';
+import { CaseDbGeneticDistanceProtocol } from '@gen-epix/api-casedb';
+import { CaseDbOrganization } from '@gen-epix/api-casedb';
+import { CaseDbOrganizationAccessCasePolicy } from '@gen-epix/api-casedb';
+import { CaseDbOrganizationShareCasePolicy } from '@gen-epix/api-casedb';
+import { CaseDbPhylogeneticTree } from '@gen-epix/api-casedb';
+import { CaseDbProtocol } from '@gen-epix/api-casedb';
+import { CaseDbRefCol } from '@gen-epix/api-casedb';
+import { CaseDbRefColValidationRulesResponseBody } from '@gen-epix/api-casedb';
+import { CaseDbRefDim } from '@gen-epix/api-casedb';
+import { CaseDbRegion } from '@gen-epix/api-casedb';
+import { CaseDbRegionRelationType } from '@gen-epix/api-casedb';
+import { CaseDbRegionSet } from '@gen-epix/api-casedb';
+import { CaseDbRetrieveCaseTypeStatsRequestBody } from '@gen-epix/api-casedb';
+import { CaseDbTreeAlgorithm } from '@gen-epix/api-casedb';
+import { CaseDbTreeAlgorithmType } from '@gen-epix/api-casedb';
+import { CaseDbUser } from '@gen-epix/api-casedb';
+import { CaseDbUserAccessCasePolicy } from '@gen-epix/api-casedb';
+import { CaseDbUserShareCasePolicy } from '@gen-epix/api-casedb';
+import { COMMON_QUERY_KEY } from '@gen-epix/ui';
+import { CommonDbApiPermission } from '@gen-epix/api-commondb';
+import { ComponentClass } from 'react';
+import { ComponentType } from 'react';
+import { ConfigBase } from '@gen-epix/ui';
+import { Context } from 'react';
+import { CreateTableStoreInitialStateKwArgs } from '@gen-epix/ui';
+import { CreateTableStoreKwArgs } from '@gen-epix/ui';
+import { default as default_2 } from 'decimal.js';
+import { ECharts } from 'echarts';
+import { EpiContactDetailsDialogOpenProps } from '@gen-epix/ui';
+import { EventBusAbstract } from '@gen-epix/ui';
+import { FilterDimension } from '@gen-epix/ui';
+import { Filters } from '@gen-epix/ui';
+import { FormFieldDefinition } from '@gen-epix/ui';
+import { GenEpixUiTheme } from '@gen-epix/ui';
+import { GetTableCellRowComparatorProps } from '@gen-epix/ui';
+import { GetTableCellValueProps } from '@gen-epix/ui';
+import { IconButtonProps } from '@mui/material';
+import { JSX } from 'react/jsx-runtime';
+import { MenuItemData } from '@gen-epix/ui';
+import { MultiSelectFilter } from '@gen-epix/ui';
+import { MyNonIndexRouteObject } from '@gen-epix/ui';
+import { ObjectSchema } from 'yup';
+import { OptionBase } from '@gen-epix/ui';
+import { PaletteMode } from '@mui/material';
+import { PersistOptions } from 'zustand/middleware';
+import { PopoverPosition } from '@mui/material';
+import { PropsWithChildren } from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+import { StoreApi } from 'zustand';
+import { Subject } from '@gen-epix/ui';
+import { SubscribableAbstract } from '@gen-epix/ui';
+import { TableColumnText } from '@gen-epix/ui';
+import { TableStoreActions } from '@gen-epix/ui';
+import { TableStoreState } from '@gen-epix/ui';
+import { TextFilter } from '@gen-epix/ui';
+import { TFunction } from 'i18next';
+import { Theme } from '@mui/material';
+import { TooltipProps } from '@mui/material';
+import { UseMap } from '@gen-epix/ui';
+import { UseNameFactory } from '@gen-epix/ui';
+import { UseOptions } from '@gen-epix/ui';
+import { UseQueryResult } from '@tanstack/react-query';
+import { WithDialogRefMethods } from '@gen-epix/ui';
+import { WithDialogRenderProps } from '@gen-epix/ui';
+import { WithDialogState } from '@gen-epix/ui';
+
+export declare class AbacUtil {
+    static createEffectieveColumnAccessRights(caseTypeAccessAbacs: CaseDbCaseTypeAccessAbac[]): Map<string, {
+        read: boolean;
+        write: boolean;
+    }>;
+}
+
+declare type AssembleUserEffectiveRightsKwArgs = {
+    caseTypeSetMembers: CaseDbCaseTypeSetMember[];
+    colSetMembers: CaseDbColSetMember[];
+    organizationAccessCasePolicies: CaseDbOrganizationAccessCasePolicy[];
+    organizationShareCasePolicies: CaseDbOrganizationShareCasePolicy[];
+    user: CaseDbUser;
+    userAccessCasePolicies: CaseDbUserAccessCasePolicy[];
+    userShareCasePolicies: CaseDbUserShareCasePolicy[];
+};
+
+export declare type CaseAbacContext = {
+    createdInDataCollection?: CaseDbDataCollection;
+    itemDataCollectionLinks: Array<Array<CaseDbCaseDataCollectionLink | CaseDbCaseSetDataCollectionLink>>;
+    itemDataCollectionOptions?: Array<OptionBase<string>[]>;
+    itemDataCollections?: Array<CaseDbDataCollection[]>;
+    itemSharedInDataCollections?: Array<CaseDbDataCollection[]>;
+    rights: Array<CaseDbCaseRights | CaseDbCaseSetRights>;
+    userDataCollectionOptions: OptionBase<string>[];
+    userDataCollections: CaseDbDataCollection[];
+    userDataCollectionsMap: Map<string, CaseDbDataCollection>;
+};
+
+export declare const CaseAbacContextProvider: (props: CaseAbacContextProviderProps) => JSX.Element;
+
+export declare type CaseAbacContextProviderProps = PropsWithChildren<{
+    readonly caseAbac: CaseAbacContext;
+}>;
+
+export declare const CASEDB_QUERY_DEPENDENCIES: Record<CASEDB_QUERY_KEY, (CASEDB_QUERY_KEY | COMMON_QUERY_KEY)[]>;
+
+export declare const CASEDB_QUERY_KEY: {
+    readonly ALLELE_PROFILES: "ALLELE_PROFILES";
+    readonly ASSEMBLY_PROTOCOLS: "ASSEMBLY_PROTOCOLS";
+    readonly CASE_DATA_COLLECTION_LINKS: "CASE_DATA_COLLECTION_LINKS";
+    readonly CASE_IDS_BY_QUERY: "CASE_IDS_BY_QUERY";
+    readonly CASE_RIGHTS: "CASE_RIGHTS";
+    readonly CASE_SET_CATEGORIES: "CASE_SET_CATEGORIES";
+    readonly CASE_SET_DATA_COLLECTION_LINKS: "CASE_SET_DATA_COLLECTION_LINKS";
+    readonly CASE_SET_MEMBERS: "CASE_SET_MEMBERS";
+    readonly CASE_SET_RIGHTS: "CASE_SET_RIGHTS";
+    readonly CASE_SET_STATS: "CASE_SET_STATS";
+    readonly CASE_SET_STATUSES: "CASE_SET_STATUSES";
+    readonly CASE_SETS: "CASE_SETS";
+    readonly CASE_TYPE_SET_CATEGORIES: "CASE_TYPE_SET_CATEGORIES";
+    readonly CASE_TYPE_SET_MEMBERS: "CASE_TYPE_SET_MEMBERS";
+    readonly CASE_TYPE_SETS: "CASE_TYPE_SETS";
+    readonly CASE_TYPE_STATS: "CASE_TYPE_STATS";
+    readonly CASE_TYPES: "CASE_TYPES";
+    readonly CASES: "CASES";
+    readonly CASES_LAZY: "CASES_LAZY";
+    readonly COL_SET_MEMBERS: "COL_SET_MEMBERS";
+    readonly COL_SETS: "COL_SETS";
+    readonly COLS: "COLS";
+    readonly COMPLETE_CASE_TYPES: "COMPLETE_CASE_TYPES";
+    readonly CONCEPT_RELATIONS: "CONCEPT_RELATIONS";
+    readonly CONCEPT_SETS: "CONCEPT_SETS";
+    readonly CONCEPTS: "CONCEPTS";
+    readonly DATA_COLLECTION_SET_MEMBERS: "DATA_COLLECTION_SET_MEMBERS";
+    readonly DATA_COLLECTION_SETS: "DATA_COLLECTION_SETS";
+    readonly DATA_COLLECTIONS: "DATA_COLLECTIONS";
+    readonly DIMS: "DIMS";
+    readonly DISEASES: "DISEASES";
+    readonly ETIOLOGICAL_AGENTS: "ETIOLOGICAL_AGENTS";
+    readonly ETIOLOGIES: "ETIOLOGIES";
+    readonly GENETIC_DISTANCE_PROTOCOLS: "GENETIC_DISTANCE_PROTOCOLS";
+    readonly GENETIC_SEQUENCES: "GENETIC_SEQUENCES";
+    readonly ORGANIZATION_ACCESS_CASE_POLICIES: "ORGANIZATION_ACCESS_CASE_POLICIES";
+    readonly ORGANIZATION_SHARE_CASE_POLICIES: "ORGANIZATION_SHARE_CASE_POLICIES";
+    readonly PHYLOGENETIC_TREE: "PHYLOGENETIC_TREE";
+    readonly REF_COLS: "REF_COLS";
+    readonly REF_COLS_VALIDATION_RULES: "REF_COLS_VALIDATION_RULES";
+    readonly REF_DIMS: "REF_DIMS";
+    readonly REGION_RELATIONS: "REGION_RELATIONS";
+    readonly REGION_SET_SHAPES: "REGION_SET_SHAPES";
+    readonly REGION_SETS: "REGION_SETS";
+    readonly REGION_SETS_LAZY: "REGION_SETS_LAZY";
+    readonly REGIONS: "REGIONS";
+    readonly REGIONS_LAZY: "REGIONS_LAZY";
+    readonly SEQUENCING_PROTOCOLS: "SEQUENCING_PROTOCOLS";
+    readonly SIMILAR_CASES: "SIMILAR_CASES";
+    readonly SUBJECTS: "SUBJECT_IDENTIFIERS";
+    readonly TREE_ALGORITHM_CLASSES: "TREE_ALGORITHM_CLASSES";
+    readonly TREE_ALGORITHMS: "TREE_ALGORITHMS";
+    readonly USER_ACCESS_CASE_POLICIES: "USER_ACCESS_CASE_POLICIES";
+    readonly USER_SHARE_CASE_POLICIES: "USER_SHARE_CASE_POLICIES";
+    readonly VALIDATE_CASES: "VALIDATE_CASES";
+    readonly XXX_CASE_ID_HAS_CASE_SET: "XXX_CASE_ID_HAS_CASE_SET";
+};
+
+export declare type CASEDB_QUERY_KEY = typeof CASEDB_QUERY_KEY[keyof typeof CASEDB_QUERY_KEY];
+
+export declare interface CaseDbConfig extends ConfigBase {
+    epi: {
+        ALLOWED_COL_TYPES_FOR_STRATIFICATION: CaseDbColType[];
+        DATA_MISSING_CHARACTER: string;
+        DOWNLOAD_SECTION_ORDER: EPI_ZONE[];
+        INITIAL_NUM_VISIBLE_ATTRIBUTES_IN_CASE_SUMMARY: number;
+        SEQDB_MAX_STORED_DISTANCE_FALLBACK: number;
+        STRATIFICATION_COLOR_ITEM_MISSING: string;
+        STRATIFICATION_COLORS: string[];
+    };
+    epiDashboard: {
+        LAYOUTS: EpiDashboardLayoutConfig[];
+        MIN_PANEL_HEIGHT: number;
+        MIN_PANEL_WIDTH: number;
+    };
+    epiLineList: {
+        CASE_SET_MEMBERS_FETCH_DEBOUNCE_DELAY_MS: number;
+        MAX_COLUMN_WIDTH: number;
+        REQUIRED_EXTRA_CELL_PADDING_TO_FIT_CONTENT: number;
+        TABLE_ROW_HEIGHT: number;
+    };
+    epiMap: {
+        MIN_PIE_CHART_RADIUS: number;
+    };
+    epiTree: {
+        ANCESTOR_DOT_RADIUS: number;
+        HEADER_HEIGHT: number;
+        INITIAL_UNLINKED_ZOOM_LEVEL: number;
+        LEAF_DOT_RADIUS: number;
+        LINKED_SCROLL_DEBOUNCE_DELAY_MS: number;
+        MAX_SCALE_WIDTH_PX: number;
+        MAX_ZOOM_LEVEL: number;
+        MAX_ZOOM_SPEED: number;
+        MIN_SCALE_WIDTH_PX: number;
+        MIN_ZOOM_LEVEL: number;
+        MIN_ZOOM_SPEED: number;
+        MINIMUM_DISTANCE_PERCENTAGE_TO_SHOW_LABEL: number;
+        PANNING_THRESHOLD: number;
+        REGULAR_FILL_COLOR_SUPPORT_LINE: string;
+        SCALE_INCREMENTS: number[];
+        TAKING_LONGER_TIMEOUT_MS: number;
+        TREE_PADDING: number;
+    };
+    trends: {
+        homePage: {
+            getSinceDate: () => string;
+            getSinceLabel: (t: TFunction<'translation', undefined>) => string;
+        };
+    };
+}
+
+export declare class CaseDbDataUtil {
+    static getCaseSetName(caseSet: CaseDbCaseSet): string;
+    static getColTypeOptionsForRefDimId(kwArgs: {
+        colsValidationRules: CaseDbRefColValidationRulesResponseBody['valid_col_types_by_dim_type'];
+        colTypeOptions: OptionBase<string>[];
+        refDimId: string;
+        refDimMap: Map<string, CaseDbRefDim>;
+    }): OptionBase<string>[];
+    static getDimOptionsForCaseTypeId(kwArgs: {
+        caseTypeId: string;
+        dimMap: Map<string, CaseDbDim>;
+        dimOptions: OptionBase<string>[];
+    }): OptionBase<string>[];
+    static getGeneticSequenceColOptionsForCaseTypeId(kwArgs: {
+        caseTypeId: string;
+        colMap: Map<string, CaseDbCol>;
+        colOptions: OptionBase<string>[];
+        refColMap: Map<string, CaseDbRefCol>;
+    }): OptionBase<string>[];
+    static getRefColOptionsForDimId(kwArgs: {
+        colsValidationRules: CaseDbRefColValidationRulesResponseBody['valid_col_types_by_dim_type'];
+        dimId: string;
+        dimMap: Map<string, CaseDbDim>;
+        refColMap: Map<string, CaseDbRefCol>;
+        refColOptions: OptionBase<string>[];
+        refDimMap: Map<string, CaseDbRefDim>;
+    }): OptionBase<string>[];
+}
+
+export declare class CaseDbDemoConfigUtil {
+    static createConfig(): CaseDbConfig;
+}
+
+export declare class CaseDbDownloadUtil {
+    static downloadAsCsv(cases: CaseDbCase[], colIds: string[], completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): void;
+    static downloadAsExcel(cases: CaseDbCase[], colIds: string[], completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): Promise<void>;
+    static downloadCanvasImage(baseName: string, canvas: HTMLCanvasElement, type: 'jpeg' | 'png', completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): void;
+    static downloadEchartsImage(baseName: string, instance: ECharts, type: 'jpeg' | 'png', completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): void;
+    static downloadExcelTemplate(caseTypeId: string, t: TFunction<'translation', undefined>): Promise<void>;
+    static downloadNewick(baseName: string, newick: string, completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): void;
+    static getExportFileName(baseName: string, completeCaseType: CaseDbCompleteCaseType, t: TFunction<'translation', undefined>): string;
+    static getTemplateFileName(completeCaseType: CaseDbCompleteCaseType): string;
+    private static getColsForImportExport;
+    private static getColumnHeadersForExport;
+    private static getColumnHeadersForImport;
+    private static getRowsForExport;
+}
+
+export declare class CaseDbTableUtil {
+    static createCaseTypeCellRowComperator({ column, dataContext, direction }: GetTableCellRowComparatorProps<TableColumnText<CaseDbCase, CaseDbCompleteCaseType, CaseDbCol>, CaseDbCompleteCaseType>): (a: CaseDbCase, b: CaseDbCase) => number;
+    static getTableCaseTypeCellValue<TRowData>({ column, dataContext, row, rowIndex }: GetTableCellValueProps<TRowData, TableColumnText<TRowData, CaseDbCompleteCaseType, CaseDbCol>, CaseDbCompleteCaseType>): string;
+}
+
+export declare const CaseDbUsersAdminPage: () => JSX.Element;
+
+export declare const CasesDetailPage: () => JSX.Element;
+
+export declare class CaseSelectionUtil {
+    static addComponentCaseIdsToSelection(componentCaseIds: string[], selectedIds: string[]): string[];
+    static canAddToSelection(componentCaseIds: string[], selectedIds: string[]): boolean;
+    static canRefineSelection(componentCaseIds: string[], selectedIds: string[]): boolean;
+    static canRemoveFromSelection(componentCaseIds: string[], selectedIds: string[]): boolean;
+    static refineSelectionWithComponentCaseIds(componentCaseIds: string[], selectedIds: string[]): string[];
+    static removeComponentCaseIdsFromSelection(componentCaseIds: string[], selectedIds: string[]): string[];
+}
+
+export declare const CaseSetCategoryAdminPage: () => JSX.Element;
+
+export declare const CaseSetStatusAdminPage: () => JSX.Element;
+
+export declare class CaseSetUtil {
+    static createCaseSetLink(caseSet: CaseDbCaseSet, full?: boolean): string;
+}
+
+export declare const CasesPage: () => JSX.Element;
+
+export declare type CaseTypeAbacContext = {
+    caseTypeAccessAbacDict: {
+        [key: string]: CaseDbCaseTypeAccessAbac;
+    };
+    caseTypeAccessAbacs?: CaseDbCaseTypeAccessAbac[];
+    effectiveColumnAccessRights?: Map<string, {
+        read: boolean;
+        write: boolean;
+    }>;
+    userDataCollections: CaseDbDataCollection[];
+    userDataCollectionsMap: Map<string, CaseDbDataCollection>;
+};
+
+export declare const CaseTypeAbacContextProvider: (props: CaseTypeAbacContextProviderProps) => JSX.Element;
+
+export declare type CaseTypeAbacContextProviderProps = PropsWithChildren<{
+    readonly caseTypeAbac: CaseTypeAbacContext;
+}>;
+
+export declare type CaseTypeRowValue = {
+    full: string;
+    isMissing?: boolean;
+    long: string;
+    raw: string;
+    short: string;
+};
+
+export declare const CaseTypesAdminPage: () => JSX.Element;
+
+export declare const CaseTypeSetCategoriesAdminPage: () => JSX.Element;
+
+export declare const caseTypeSetCategoryPurposePresentationValues: Record<CaseDbCaseTypeSetCategoryPurpose, string>;
+
+export declare const CaseTypeSetsAdminPage: () => JSX.Element;
+
+export declare const caseTypesQueryFn: ({ signal }: {
+    signal: AbortSignal;
+}) => Promise<CaseDbCaseType[]>;
+
+export declare class CaseTypeUtil {
+    static createCaseTypeLink(caseType: CaseDbCaseType | CaseDbCompleteCaseType, full?: boolean): string;
+    /**
+     * Find paired FWD/REV columns in the same dimension.
+     * @param completeCaseType The complete case type object.
+     * @returns An array of paired FWD/REV columns.
+     */
+    static findPairedReadsCols(completeCaseType: CaseDbCompleteCaseType): {
+        fwd: CaseDbCol;
+        rev: CaseDbCol;
+    }[];
+    /**
+     * Find a unique column by its column ID or column ID.
+     * @param completeCaseType The complete case type object.
+     * @param id The ID of the column or column.
+     * @returns The unique column if found, otherwise null.
+     */
+    static findUniqueColByColIdRefOrColId(completeCaseType: CaseDbCompleteCaseType, id: string): CaseDbCol;
+    static getCols(completeCaseType: CaseDbCompleteCaseType, dimId?: string): CaseDbCol[];
+    /**
+     * Get columns by their column type.
+     * @param completeCaseType The complete case type object.
+     * @param colType The column type to filter by.
+     * @returns An array of columns matching the specified column type.
+     */
+    static getColsByType(completeCaseType: CaseDbCompleteCaseType, colType: CaseDbColType[]): CaseDbCol[];
+    static getDimLabel(completeCaseType: CaseDbCompleteCaseType, dimId: string): string;
+    static getDims(completeCaseType: CaseDbCompleteCaseType, dimTypes?: CaseDbDimType[]): CaseDbDim[];
+    static getInitialVisibleColIds(completeCaseType: CaseDbCompleteCaseType): string[];
+    static getPreferredColInDimHavingHighestRank(cols: CaseDbCol[], completeCaseType: CaseDbCompleteCaseType): CaseDbCol;
+    static getPreferredGEOCol(cols: CaseDbCol[]): CaseDbCol;
+    static getWritableColIds(completeCaseType: CaseDbCompleteCaseType): string[];
+    static getWritableImportExportColIds(completeCaseType: CaseDbCompleteCaseType): string[];
+    static isGeneticDistanceDim(refDim: CaseDbRefDim, refCols: CaseDbRefCol[]): boolean;
+}
+
+export declare type CaseUploadResultWithGeneratedId = {
+    generatedId: string;
+} & CaseDbCaseUploadResult;
+
+export declare class CaseUtil {
+    static applyDataCollectionLinks(kwArgs: {
+        caseIds?: string[];
+        caseSetDataCollectionIds: string[];
+        caseSetId?: string;
+        caseTypeId: string;
+    }): Promise<void>;
+    static createFormFieldDefinitions(completeCaseType: CaseDbCompleteCaseType, organizationsQueryResult: UseQueryResult<CaseDbOrganization[]>): FormFieldDefinition<CaseDbCase['content']>[];
+    static createYupSchema(completeCaseType: CaseDbCompleteCaseType): ObjectSchema<{
+        [key: string]: string;
+    }>;
+    static getMappedValue(raw: string, col: CaseDbCol, completeCaseType: CaseDbCompleteCaseType, machineReadable?: boolean): CaseTypeRowValue;
+    static getMissingRowValue(raw: string, machineReadable?: boolean): CaseTypeRowValue;
+    static getRowValue(content: {
+        [key: string]: string;
+    }, col: CaseDbCol, completeCaseType: CaseDbCompleteCaseType, machineReadable?: boolean): CaseTypeRowValue;
+    private static getConceptMappedValue;
+    private static getOrganizationMappedValue;
+    private static getRegionMappedValue;
+}
+
+export declare const ColsAdminPage: () => JSX.Element;
+
+export declare const ColSetsAdminPage: () => JSX.Element;
+
+export declare const colTypePresentationValues: Record<CaseDbColType, string>;
+
+export declare const ConceptRelationsAdminPage: () => JSX.Element;
+
+export declare const conceptRelationTypePresentationValues: Partial<Record<CaseDbConceptRelationType, string>>;
+
+export declare const ConceptsAdminPage: () => JSX.Element;
+
+export declare const ConceptSetsAdminPage: () => JSX.Element;
+
+export declare const conceptSetTypePresentationValues: Partial<Record<CaseDbConceptSetType, string>>;
+
+export declare const createAdminRoutes: () => MyNonIndexRouteObject<RoutePermission>[];
+
+export declare const createCaseDbDemoTheme: (paletteMode: PaletteMode) => Theme;
+
+export declare const createEpiDashboardStore: (kwArgs: CreateEpiDashboardStoreKwArgs) => Omit<StoreApi<EpiDashboardStore>, "persist" | "setState"> & {
+    setState(partial: EpiDashboardStore | Partial<EpiDashboardStore> | ((state: EpiDashboardStore) => EpiDashboardStore | Partial<EpiDashboardStore>), replace?: false): unknown;
+    setState(state: EpiDashboardStore | ((state: EpiDashboardStore) => EpiDashboardStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<PersistOptions<EpiDashboardStore, EpiDashboardStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: EpiDashboardStore) => void) => () => void;
+        onFinishHydration: (fn: (state: EpiDashboardStore) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<EpiDashboardStore, EpiDashboardStore, unknown>>;
+    };
+};
+
+export declare interface CreateEpiDashboardStoreInitialStateKwArgs extends CreateTableStoreInitialStateKwArgs<CaseDbCase, CaseDbCompleteCaseType> {
+    caseSetId: string;
+    completeCaseType: CaseDbCompleteCaseType;
+}
+
+export declare type CreateEpiDashboardStoreKwArgs = {
+    caseSetId: string;
+    completeCaseType: CaseDbCompleteCaseType;
+} & CreateTableStoreKwArgs<CaseDbCase, CaseDbCompleteCaseType>;
+
+export declare const createEpiUploadStore: () => StoreApi<EpiUploadStore>;
+
+export declare const createRoutes: (adminRoutes?: MyNonIndexRouteObject<RoutePermission_2>[]) => MyNonIndexRouteObject<RoutePermission_2>[];
+
+export declare const createUserProfileStoreInitialState: () => UserProfileStoreState;
+
+export declare class DashboardUtil {
+    static readonly dashboardLayoutStorageKey = "GENEPIX-EpiDashboard-Layout-v1.3";
+    static createDashboardLayoutUserConfigInitialState(): EpiDashboardLayoutUserConfig;
+    static getDashboardLayout(userConfig: EpiDashboardLayoutUserConfig): EpiDashboardLayout;
+    static getDashboardLayoutConfig(userConfig: EpiDashboardLayoutUserConfig): EpiDashboardLayoutConfig;
+    static getEnabledZones(userConfig: EpiDashboardLayoutUserConfig): EPI_ZONE[];
+    static isSingleWidget(userConfig: EpiDashboardLayoutUserConfig, zone: EPI_ZONE): boolean;
+}
+
+export declare const DataCollectionsAdminPage: () => JSX.Element;
+
+export declare const DataCollectionSetsAdminPage: () => JSX.Element;
+
+export declare const DataCollectionVisualizationPage: () => JSX.Element;
+
+export declare class DataSetUtil {
+    static getCategorizedSetMembers(kwArgs: {
+        childMemberIds: string[];
+        mappedSetMembers: Map<string, string[]>;
+        parentMemberIds: string[];
+        parentSetId: string;
+    }): {
+        categorizedMemberIds: string[];
+        setIds: string[];
+        uncategorizedMemberIds: string[];
+    };
+    static getMappedSetMembers<T>(kwArgs: {
+        items: T[];
+        memberProperty: keyof T & string;
+        setProperty: keyof T & string;
+    }): Map<string, string[]>;
+}
+
+export declare const DimsAdminPage: () => JSX.Element;
+
+export declare const dimTypePresentationValues: Record<CaseDbDimType, string>;
+
+export declare const DiseasesAdminPage: () => JSX.Element;
+
+export declare type DownloadConfig = {
+    disabled?: boolean;
+    items: DownloadConfigItems[];
+    zone: EPI_ZONE;
+    zoneLabel: string;
+};
+
+export declare type DownloadConfigItem = {
+    callback: () => void;
+    disabled?: boolean;
+    label: string;
+};
+
+export declare type DownloadConfigItems = DownloadConfigItem | DownloadConfigSection;
+
+export declare type DownloadConfigSection = {
+    disabled?: boolean;
+    items: DownloadConfigItem[];
+    label: string;
+};
+
+export declare class EffectiveRightsUtil {
+    static assembleUserEffectiveRights({ caseTypeSetMembers, colSetMembers, organizationAccessCasePolicies, organizationShareCasePolicies, user, userAccessCasePolicies, userShareCasePolicies, }: AssembleUserEffectiveRightsKwArgs): UserEffectiveRight[];
+    static getMatchingOrganizationShareCasePolicies(params: {
+        dataCollectionId: string;
+        organizationId: string;
+        organizationShareCasePolicies: CaseDbOrganizationShareCasePolicy[];
+    }): CaseDbOrganizationShareCasePolicy[];
+    static getOrganizationPolicyGroups({ organizationAccessCasePolicies, organizationShareCasePolicies, }: GetOrganizationPolicyGroupsKwArgs): OrganizationPolicyGroup[];
+    private static getOrganizationDataCollectionKey;
+}
+
+export declare enum EPI_UPLOAD_STEP {
+    SELECT_FILE = 0,
+    MAP_COLUMNS = 1,
+    VALIDATE = 2,
+    SELECT_SEQUENCE_FILES = 3,
+    MAP_SEQUENCES = 4,
+    CREATE_CASES = 5
+}
+
+export declare enum EPI_ZONE {
+    EPI_CURVE = "EPI_CURVE",
+    LEGENDA = "LEGENDA",
+    LINE_LIST = "LINE_LIST",
+    MAP = "MAP",
+    TREE = "TREE"
+}
+
+export declare const EpiAddCasesToEventDialog: ComponentClass<EpiAddCasesToEventDialogProps, WithDialogState<EpiAddCasesToEventDialogOpenProps>>;
+
+export declare interface EpiAddCasesToEventDialogOpenProps {
+    currentCaseSet: CaseDbCaseSet;
+    rows: CaseDbCase[];
+}
+
+export declare interface EpiAddCasesToEventDialogProps extends WithDialogRenderProps<EpiAddCasesToEventDialogOpenProps> {
+}
+
+export declare type EpiAddCasesToEventDialogRefMethods = WithDialogRefMethods<EpiAddCasesToEventDialogProps, EpiAddCasesToEventDialogOpenProps>;
+
+export declare const EpiBulkEditCaseDialog: ComponentClass<EpiBulkEditCaseDialogProps, WithDialogState<EpiBulkEditCaseDialogOpenProps>>;
+
+export declare interface EpiBulkEditCaseDialogOpenProps {
+    rows: CaseDbCase[];
+}
+
+export declare interface EpiBulkEditCaseDialogProps extends WithDialogRenderProps<EpiBulkEditCaseDialogOpenProps> {
+}
+
+export declare type EpiBulkEditCaseDialogRefMethods = WithDialogRefMethods<EpiBulkEditCaseDialogProps, EpiBulkEditCaseDialogOpenProps>;
+
+export declare const EpiCaseAbacContext: Context<CaseAbacContext>;
+
+export declare type EpiCaseHasCaseSet = {
+    [caseId: string]: boolean;
+};
+
+export declare const EpiCaseInfoDialog: ComponentClass<EpiCaseInfoDialogProps, WithDialogState<EpiCaseInfoDialogOpenProps>>;
+
+export declare interface EpiCaseInfoDialogOpenProps {
+    caseId: string;
+    caseTypeId: string;
+}
+
+export declare interface EpiCaseInfoDialogProps extends WithDialogRenderProps<EpiCaseInfoDialogOpenProps> {
+}
+
+export declare type EpiCaseInfoDialogRefMethods = WithDialogRefMethods<EpiCaseInfoDialogProps, EpiCaseInfoDialogOpenProps>;
+
+export declare const EpiCasesAlreadyInCaseSetWarning: ({ cases }: EpiCasesAlreadyInCaseSetWarningProps) => JSX.Element;
+
+export declare type EpiCasesAlreadyInCaseSetWarningProps = {
+    readonly cases: CaseDbCase[];
+};
+
+export declare const EpiCaseSetInfoDialog: ComponentClass<EpiCaseSetInfoDialogProps, WithDialogState<EpiCaseSetInfoDialogOpenProps>>;
+
+export declare interface EpiCaseSetInfoDialogOpenProps {
+    readonly caseSetId: string;
+    readonly caseTypeId: string;
+}
+
+export declare interface EpiCaseSetInfoDialogProps extends WithDialogRenderProps<EpiCaseSetInfoDialogOpenProps> {
+    readonly showNavigationButton?: boolean;
+}
+
+export declare type EpiCaseSetInfoDialogRefMethods = WithDialogRefMethods<EpiCaseSetInfoDialogProps, EpiCaseSetInfoDialogOpenProps>;
+
+export declare const EpiCaseSummary: ({ epiCase }: EpiCaseSummaryProps) => JSX.Element;
+
+export declare type EpiCaseSummaryProps = {
+    readonly epiCase: CaseDbCase;
+};
+
+export declare const EpiCaseTypeAbacContext: Context<CaseTypeAbacContext>;
+
+export declare const EpiCaseTypeInfoAccessRights: ({ completeCaseType }: EpiCaseTypeInfoAccessRightsProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoAccessRightsProps = {
+    readonly completeCaseType: CaseDbCompleteCaseType;
+};
+
+export declare const EpiCaseTypeInfoColAccessRights: ({ colId }: EpiCaseTypeInfoColAccessRightsProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoColAccessRightsProps = {
+    readonly colId: string;
+};
+
+export declare const EpiCaseTypeInfoData: ({ name, title }: EpiCaseTypeInfoDataProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoDataProps = {
+    readonly name: string;
+    readonly title: string;
+};
+
+export declare const EpiCaseTypeInfoDialog: ComponentClass<EpiCaseTypeInfoDialogProps, WithDialogState<EpiCaseTypeInfoDialogOpenProps>>;
+
+export declare const EpiCaseTypeInfoDialogContent: ({ onPermalinkChange, onTitleChange }: EpiCaseTypeInfoDialogContentProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoDialogContentProps = Pick<WithDialogRenderProps, 'onPermalinkChange' | 'onTitleChange'>;
+
+export declare interface EpiCaseTypeInfoDialogOpenProps {
+}
+
+export declare interface EpiCaseTypeInfoDialogProps extends WithDialogRenderProps<EpiCaseTypeInfoDialogOpenProps> {
+}
+
+export declare type EpiCaseTypeInfoDialogRefMethods = WithDialogRefMethods<EpiCaseTypeInfoDialogProps, EpiCaseTypeInfoDialogOpenProps>;
+
+export declare const EpiCaseTypeInfoDialogWithLoader: ComponentClass<EpiCaseTypeInfoDialogWithLoaderProps, WithDialogState<EpiCaseTypeInfoDialogWithLoaderOpenProps>>;
+
+export declare interface EpiCaseTypeInfoDialogWithLoaderOpenProps {
+    caseTypeId: string;
+}
+
+export declare interface EpiCaseTypeInfoDialogWithLoaderProps extends WithDialogRenderProps<EpiCaseTypeInfoDialogWithLoaderOpenProps> {
+}
+
+export declare type EpiCaseTypeInfoDialogWithLoaderRefMethods = WithDialogRefMethods<EpiCaseTypeInfoDialogWithLoaderProps, EpiCaseTypeInfoDialogWithLoaderOpenProps>;
+
+export declare const EpiCaseTypeInfoRegions: ({ completeCaseType }: EpiCaseTypeInfoRegionsProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoRegionsProps = {
+    readonly completeCaseType: CaseDbCompleteCaseType;
+};
+
+export declare const EpiCaseTypeInfoTrees: ({ completeCaseType }: EpiCaseTypeInfoTreesProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoTreesProps = {
+    readonly completeCaseType: CaseDbCompleteCaseType;
+};
+
+export declare const EpiCaseTypeInfoValues: ({ completeCaseType }: EpiCaseTypeInfoValuesProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoValuesProps = {
+    readonly completeCaseType: CaseDbCompleteCaseType;
+};
+
+export declare const EpiCaseTypeInfoVariableDetails: ({ completeCaseType, dim }: EpiCaseTypeInfoVariableDetailsProps) => JSX.Element;
+
+export declare type EpiCaseTypeInfoVariableDetailsProps = {
+    readonly completeCaseType: CaseDbCompleteCaseType;
+    readonly dim: CaseDbDim;
+};
+
+export declare const EpiCompletCaseTypeLoader: ({ caseTypeId, children, onCompleteCaseTypeLoaded }: EpiCompletCaseTypeLoaderProps) => JSX.Element;
+
+export declare type EpiCompletCaseTypeLoaderProps = PropsWithChildren<{
+    readonly caseTypeId: string;
+    readonly onCompleteCaseTypeLoaded?: (completeCaseType: CaseDbCompleteCaseType) => void;
+}>;
+
+export declare const EpiContextMenu: ({ config, getExtraItems, onMenuClose }: EpiContextMenuProps) => JSX.Element;
+
+declare type EpiContextMenuConfig = EpiContextMenuConfigWithAnchor & EpiContextMenuConfigWithPosition;
+
+export declare type EpiContextMenuConfigWithAnchor = {
+    anchorElement?: Element;
+    mouseEvent?: MouseEvent;
+    parseIdsFromAnchorElement?: (element: Element) => string[];
+};
+
+export declare type EpiContextMenuConfigWithPosition = {
+    caseIds?: string[];
+    mouseEvent?: MouseEvent;
+    position?: PopoverPosition;
+};
+
+export declare type EpiContextMenuProps = {
+    readonly config: EpiContextMenuConfig;
+    readonly getExtraItems?: (onMenuClose?: () => void) => ReactElement;
+    readonly onMenuClose: () => void;
+};
+
+export declare const EpiCreateEventDialog: ComponentClass<EpiCreateEventDialogProps, WithDialogState<EpiCreateEventDialogOpenProps>>;
+
+export declare interface EpiCreateEventDialogOpenProps {
+    readonly completeCaseType?: CaseDbCompleteCaseType;
+    readonly rows?: CaseDbCase[];
+}
+
+export declare interface EpiCreateEventDialogProps extends WithDialogRenderProps<EpiCreateEventDialogOpenProps> {
+}
+
+export declare type EpiCreateEventDialogRefMethods = WithDialogRefMethods<EpiCreateEventDialogProps, EpiCreateEventDialogOpenProps>;
+
+export declare class EpiCurveUtil {
+    static getItemsWithinInterval(items: Item[], intervals: Date[], index: number): Item[];
+    /**
+     * Finds the initial column (resolution) for the given dimensionId in the given lineList
+     * @param completeCaseType
+     * @param lineList
+     * @param cols
+     * @returns
+     */
+    static getPreferredTimeColumn(completeCaseType: CaseDbCompleteCaseType, cases: CaseDbCase[], cols: CaseDbCol[]): CaseDbCol;
+    /**
+     * Gets rows sorted by time
+     * @param completeCaseType
+     * @param lineList
+     * @param cols
+     * @returns
+     */
+    static getSortedItems(completeCaseType: CaseDbCompleteCaseType, cases: CaseDbCase[], cols: CaseDbCol[]): Item[];
+    static getXAxisIntervals(colType: CaseDbColType, items: Item[]): Date[];
+    static getXAxisLabel(colType: CaseDbColType, value: Date): string;
+}
+
+export declare const EpiCurveWidget: () => JSX.Element;
+
+declare interface EpiCurveWidgetData extends WidgetData {
+    columnId: string;
+    dimensionId: string;
+}
+
+export declare const EpiCustomTabPanel: (props: EpiCustomTabPanelProps) => JSX.Element;
+
+export declare type EpiCustomTabPanelProps = PropsWithChildren<{
+    readonly index: number;
+    readonly value: number;
+}>;
+
+export declare const EpiDashboard: ComponentType<EpiDashboardProps>;
+
+export declare type EpiDashboardGeneralSettings = {
+    isHighlightingEnabled: boolean;
+};
+
+export declare type EpiDashboardLayout = [EpiDashboardLayoutPanelOrientation, ...EpiDashboardLayoutFirstAxisPanel[]];
+
+export declare type EpiDashboardLayoutConfig = {
+    layouts: EpiDashboardLayout[];
+    zones: EPI_ZONE[];
+};
+
+export declare type EpiDashboardLayoutFirstAxisPanel = [100 | 30 | 50 | 70, ...EpiDashboardLayoutSecondAxisPanel[]];
+
+export declare type EpiDashboardLayoutPanelOrientation = 'horizontal' | 'vertical';
+
+export declare type EpiDashboardLayoutSecondAxisPanel = [100 | 30 | 50 | 70, EPI_ZONE];
+
+export declare type EpiDashboardLayoutUserConfig = {
+    arrangement: number;
+    zones: {
+        [EPI_ZONE.EPI_CURVE]: boolean;
+        [EPI_ZONE.LINE_LIST]: boolean;
+        [EPI_ZONE.MAP]: boolean;
+        [EPI_ZONE.TREE]: boolean;
+    };
+};
+
+declare type EpiDashboardProps = {
+    readonly caseSet?: CaseDbCaseSet;
+    readonly caseTypeId: string;
+};
+
+export declare type EpiDashboardStore = EpiDashboardStoreActions & EpiDashboardStoreState;
+
+declare interface EpiDashboardStoreActions extends TableStoreActions<CaseDbCase, CaseDbCompleteCaseType> {
+    addTreeFilter: (nodeId: string) => Promise<void>;
+    destroy: () => void;
+    expandZone: (zone: EPI_ZONE) => void;
+    mutateCachedCase: (caseId: string, item: CaseDbCase) => void;
+    reloadStratification: () => void;
+    reloadStratifyableColumns: () => void;
+    reloadTree: () => void;
+    removeTreeFilter: () => Promise<void>;
+    resetTreeAddresses: () => void;
+    setFindSimilarCasesResults: (findSimilarCasesResults: FindSimilarCasesResult[]) => Promise<void>;
+    setNumVisibleAttributesInSummary: (numVisibleAttributesInSummary: number) => void;
+    setPhylogeneticTreeResponse: (phylogeneticTree: CaseDbPhylogeneticTree) => void;
+    stratify: (mode: STRATIFICATION_MODE, col?: CaseDbCol) => void;
+    treeFilterStepOut: () => Promise<void>;
+    updateEpiCurveWidgetData: (data: Partial<EpiCurveWidgetData>) => void;
+    updateEpiListWidgetData: (data: Partial<EpiListWidgetData>) => void;
+    updateEpiMapWidgetData: (data: Partial<EpiMapWidgetData>) => void;
+    updateEpiTreeWidgetData: (data: Partial<EpiTreeWidgetData>) => void;
+}
+
+export declare const EpiDashboardStoreContext: Context<StoreApi<EpiDashboardStore>>;
+
+export declare const EpiDashboardStoreLoader: ({ caseSet, caseTypeId, children }: EpiDashboardStoreLoaderProps) => JSX.Element;
+
+export declare type EpiDashboardStoreLoaderProps = PropsWithChildren<{
+    readonly caseSet?: CaseDbCaseSet;
+    readonly caseTypeId: string;
+}>;
+
+declare interface EpiDashboardStoreState extends TableStoreState<CaseDbCase, CaseDbCompleteCaseType> {
+    caseSetId: string;
+    completeCaseType: CaseDbCompleteCaseType;
+    epiCurveWidgetData: EpiCurveWidgetData;
+    epiListWidgetData: EpiListWidgetData;
+    epiMapWidgetData: EpiMapWidgetData;
+    epiTreeWidgetData: EpiTreeWidgetData;
+    expandedZone: EPI_ZONE;
+    findSimilarCasesResults: FindSimilarCasesResult[];
+    isMaxResultsExceeded: boolean;
+    isMaxResultsExceededDismissed: boolean;
+    newick: string;
+    numVisibleAttributesInSummary: number;
+    stratification: Stratification;
+    stratifyableColumns: StratifiableColumn[];
+    tree: TreeNode;
+    treeAddresses: {
+        [key: string]: {
+            addresses: {
+                [key: string]: string;
+            };
+            algorithmCode: string;
+        };
+    };
+    treeResponse: TreeNode;
+}
+
+export declare type EpiDashboardTreeSettings = {
+    isShowDistancesEnabled: boolean;
+    isShowSupportLinesWhenUnlinkedEnabled?: boolean;
+};
+
+export declare type EpiData = {
+    conceptsById: {
+        [id: string]: CaseDbConcept;
+    };
+    conceptsBySetId: {
+        [id: string]: CaseDbConcept[];
+    };
+    conceptSets: {
+        [id: string]: CaseDbConceptSet;
+    };
+    conceptsIdsBySetId: {
+        [id: string]: string[];
+    };
+    organizations: CaseDbOrganization[];
+    organizationsById: {
+        [id: string]: CaseDbOrganization;
+    };
+    regionsById: {
+        [id: string]: CaseDbRegion;
+    };
+    regionsByRegionSetId: {
+        [id: string]: CaseDbRegion[];
+    };
+    regionSets: {
+        [id: string]: CaseDbRegionSet;
+    };
+    treeAlgorithms: CaseDbTreeAlgorithm[];
+    userDataCollections: CaseDbDataCollection[];
+    userDataCollectionsById: {
+        [id: string]: CaseDbDataCollection;
+    };
+};
+
+export declare const EpiDataCollectionAccessInfo: () => JSX.Element;
+
+export declare class EpiDataManager {
+    private static __instance;
+    readonly data: EpiData;
+    private constructor();
+    static getInstance(): EpiDataManager;
+    getRegionSetIds(completeCaseType: CaseDbCompleteCaseType): string[];
+    loadConcepts(signal: AbortSignal): Promise<void>;
+    loadMissingRegions(completeCaseType: CaseDbCompleteCaseType, signal: AbortSignal): Promise<void>;
+    loadOrganizations(signal: AbortSignal): Promise<void>;
+    loadTreeAlgorithms(completeCaseType: CaseDbCompleteCaseType, signal: AbortSignal): Promise<void>;
+    private getMissingRegionSetIds;
+}
+
+declare type EpiEvent = {
+    onDownloadOptionsChanged: DownloadConfig;
+    onDownloadOptionsRequested: void;
+    onEventCreated: void;
+    openAddCasesToEventDialog: EpiAddCasesToEventDialogOpenProps;
+    openBulkEditCaseDialog: EpiBulkEditCaseDialogOpenProps;
+    openCaseInfoDialog: EpiCaseInfoDialogOpenProps;
+    openContactDetailsDialog: EpiContactDetailsDialogOpenProps;
+    openCreateEventDialog: EpiCreateEventDialogOpenProps;
+    openFiltersMenu: void;
+    openFindSimilarCasesDialog: EpiFindSimilarCasesDialogOpenProps;
+    openRemoveCasesFromEventDialog: EpiRemoveCasesFromEventDialogOpenProps;
+    openRemoveFindSimilarCasesResultDialog: EpiRemoveFindSimilarCasesResultDialogOpenProps;
+    openSequenceDownloadDialog: EpiSequenceDownloadDialogOpenProps;
+};
+
+export declare class EpiEventBusManager extends EventBusAbstract<EpiEvent> {
+    private static __instance;
+    private constructor();
+    static getInstance(): EpiEventBusManager;
+}
+
+export declare class EpiFilterUtil {
+    private static readonly colTypeBlackList;
+    static createCategoricalFilter(col: CaseDbCol, dimId: string, completeCaseType: CaseDbCompleteCaseType): MultiSelectFilter | TextFilter;
+    static createFilterDimensions(completeCaseType: CaseDbCompleteCaseType): FilterDimension[];
+    static createFilters(completeCaseType: CaseDbCompleteCaseType): Filters;
+    static getDateParser(refCol: CaseDbRefCol): (date: string) => Date;
+}
+
+export declare const EpiFindSimilarCasesDialog: ComponentClass<EpiFindSimilarCasesDialogProps, WithDialogState<EpiFindSimilarCasesDialogOpenProps>>;
+
+export declare interface EpiFindSimilarCasesDialogOpenProps {
+    allRows: CaseDbCase[];
+    completeCaseType: CaseDbCompleteCaseType;
+    selectedRows: CaseDbCase[];
+}
+
+export declare interface EpiFindSimilarCasesDialogProps extends WithDialogRenderProps<EpiFindSimilarCasesDialogOpenProps> {
+}
+
+export declare type EpiFindSimilarCasesDialogRefMethods = WithDialogRefMethods<EpiFindSimilarCasesDialogProps, EpiFindSimilarCasesDialogOpenProps>;
+
+export declare class EpiHighlightingManager extends SubscribableAbstract<Highlighting> {
+    private static __instance;
+    protected constructor();
+    static getInstance(): EpiHighlightingManager;
+    highlight(highlighting: Highlighting): void;
+    reset(): void;
+}
+
+export declare const EpiLegendaItem: ({ children, item, tooltip, tooltipProps }: EpiLegendaItemProps) => JSX.Element;
+
+export declare type EpiLegendaItemProps = {
+    readonly children?: ReactNode;
+    readonly item: StratificationLegendaItem;
+    readonly tooltip?: boolean;
+    readonly tooltipProps?: Partial<TooltipProps>;
+};
+
+export declare class EpiLineListCaseSetMembersManager {
+    private static __instance;
+    private readonly queuedCases;
+    private constructor();
+    static getInstance(): EpiLineListCaseSetMembersManager;
+    cleanStaleQueue(): void;
+    loadRange(caseIds: string[]): Promise<void>;
+    query(caseId: string): Promise<boolean>;
+    private createQueueItem;
+    private getItemFromCache;
+}
+
+export declare type EpiLineListRangeSubjectValue = {
+    endIndex: number;
+    startIndex: number;
+};
+
+export declare class EpiLineListUtil {
+    static getCaseCount(cases: CaseDbCase[]): number;
+    static getSelectedRows(cases: CaseDbCase[], selectedIds: string[]): CaseDbCase[];
+}
+
+export declare const EpiLineListWidget: ({ caseSet, lineListRangeSubject, linkedScrollSubject, onLink }: EpiLineListWidgetProps) => JSX.Element;
+
+export declare type EpiLineListWidgetProps = {
+    readonly caseSet?: CaseDbCaseSet;
+    readonly lineListRangeSubject: Subject<EpiLineListRangeSubjectValue>;
+    readonly linkedScrollSubject: Subject<EpiLinkedScrollSubjectValue>;
+    readonly onLink: () => void;
+};
+
+export declare type EpiLinkedScrollSubjectValue = {
+    origin: HTMLElement;
+    position: number;
+};
+
+declare interface EpiListWidgetData extends WidgetData {
+    visibleItemItemIndex: number;
+}
+
+export declare class EpiMapUtil {
+    static getGeoJsonAspectScale(geoJson: string): number;
+    static getPieChartRadius(numCases: number, maxPieChartArea: number, statistics: RegionStatistics): number;
+    static getRegionStatistics(cases: CaseDbCase[], columnId: string, regions: CaseDbRegion[]): RegionStatistics;
+    private static createEmptyBounds;
+    private static expandBoundsFromCoordinates;
+    private static expandBoundsFromFeature;
+    private static expandBoundsFromGeometry;
+    private static getGeoJsonBounds;
+    private static getGeoJsonObjectBounds;
+    private static hasBounds;
+    private static mergeBounds;
+    private static normalizeBounds;
+}
+
+export declare const EpiMapWidget: () => JSX.Element;
+
+declare interface EpiMapWidgetData extends WidgetData {
+    columnId: string;
+    dimensionId: string;
+}
+
+export declare const EpiRemoveCasesFromEventDialog: ComponentClass<EpiRemoveCasesFromEventDialogProps, WithDialogState<EpiRemoveCasesFromEventDialogOpenProps>>;
+
+export declare interface EpiRemoveCasesFromEventDialogOpenProps {
+    caseSet: CaseDbCaseSet;
+    rows: CaseDbCase[];
+}
+
+export declare interface EpiRemoveCasesFromEventDialogProps extends WithDialogRenderProps<EpiRemoveCasesFromEventDialogOpenProps> {
+}
+
+export declare type EpiRemoveCasesFromEventDialogRefMethods = WithDialogRefMethods<EpiRemoveCasesFromEventDialogProps, EpiRemoveCasesFromEventDialogOpenProps>;
+
+declare interface EpiRemoveFindSimilarCasesResultDialogOpenProps {
+    completeCaseType: CaseDbCompleteCaseType;
+}
+
+export declare const EpiSequenceDownloadDialog: ComponentClass<EpiSequenceDownloadDialogProps, WithDialogState<EpiSequenceDownloadDialogOpenProps>>;
+
+export declare interface EpiSequenceDownloadDialogOpenProps {
+    cases: CaseDbCase[];
+    geneticSequenceColId?: string;
+}
+
+export declare interface EpiSequenceDownloadDialogProps extends WithDialogRenderProps<EpiSequenceDownloadDialogOpenProps> {
+}
+
+export declare type EpiSequenceDownloadDialogRefMethods = WithDialogRefMethods<EpiSequenceDownloadDialogProps, EpiSequenceDownloadDialogOpenProps>;
+
+export declare const EpiStratification: () => JSX.Element;
+
+export declare const EpiTreeDescription: ({ treeConfiguration, }: EpiTreeDescriptionProps) => JSX.Element;
+
+export declare type EpiTreeDescriptionProps = {
+    readonly treeConfiguration: TreeConfiguration;
+};
+
+export declare class EpiTreeUtil {
+    /**
+     * Traverses the tree and produces a {@link TreeAssembly} containing all
+     * pre-computed `Path2D` shapes and metadata needed to render the tree.
+     *
+     * Leaf nodes are assembled in DFS order (incrementing `leafIndex`), which
+     * determines their vertical position. Ancestor nodes are positioned vertically
+     * at the midpoint of their first and last child.
+     *
+     * @param params.rootNode - The root of the tree to assemble.
+     * @param params.treeCanvasWidth - Width of the tree canvas in pixels, used for support lines.
+     * @param params.pixelToGeneticDistanceRatio - Pixels per unit of genetic distance.
+     * @param params.itemHeight - Height of each row/item in pixels.
+     * @param params.externalLeafSorting - Custom sorting order of leaf nodes by name, derived from external ordering (e.g. table row order). Must contain all leaf node names.
+     * @returns A fully populated {@link TreeAssembly} ready for rendering.
+     */
+    static assembleTree(params: {
+        externalLeafSorting: string[];
+        itemHeight: number;
+        pixelToGeneticDistanceRatio: number;
+        rootNode: TreeNode;
+        treeCanvasWidth: number;
+    }): TreeAssembly;
+    /**
+     * Assigns a dot-notation address to every node in the tree, representing its
+     * position in the hierarchy (e.g. `"1.2.1"`). Zero-branch-length children are
+     * always placed at index `1`; other children are indexed starting at `1` or
+     * `2` depending on whether a zero-branch sibling is present.
+     *
+     * @param rootNode - The root of the tree to address.
+     * @returns A map from node name to its dot-notation address string.
+     */
+    static createTreeAddresses(rootNode: TreeNode): {
+        [key: string]: string;
+    };
+    /**
+     * Draws a thin horizontal divider line across the full canvas width.
+     *
+     * Used to visually separate the scale header from the tree body.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.y - Vertical position of the divider in logical pixels.
+     * @param params.devicePixelRatio - Screen DPR for correct positioning.
+     */
+    static drawDivider(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        y: number;
+    }): void;
+    /**
+     * Draws vertical dashed guide lines on the canvas at each tick mark position.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.tickerMarkScale - Scale tuple from {@link getTickMarkScale}.
+     * @param params.geneticTreeWidth - Total genetic width of the tree.
+     * @param params.pixelToGeneticDistanceRatio - Pixels per unit of genetic distance.
+     * @param params.devicePixelRatio - Screen DPR.
+     * @param params.paddingTop - Top inset in pixels to leave blank (default 0).
+     * @param params.paddingBottom - Bottom inset in pixels to leave blank (default 0).
+     * @param params.zoomLevel - Current zoom level.
+     * @param params.horizontalScrollPosition - Current horizontal scroll offset in pixels.
+     */
+    static drawGuides(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        endY?: number;
+        geneticTreeWidth: default_2;
+        horizontalScrollPosition: number;
+        paddingBottom?: number;
+        paddingTop?: number;
+        pixelToGeneticDistanceRatio: number;
+        startY?: number;
+        tickerMarkScale: TickerMarkScale;
+        zoomLevel: number;
+    }): void;
+    /**
+     * Draws the genetic distance scale labels onto the canvas header area.
+     *
+     * Labels are drawn in reverse order (right-to-left distance decreasing) so
+     * the leftmost label shows the largest genetic distance.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.theme - MUI theme providing the font family.
+     * @param params.tickerMarkScale - Scale tuple from {@link getTickMarkScale}.
+     * @param params.geneticTreeWidth - Total genetic width of the tree.
+     * @param params.pixelToGeneticDistanceRatio - Pixels per unit of genetic distance.
+     * @param params.zoomLevel - Current zoom level.
+     * @param params.devicePixelRatio - Screen DPR.
+     * @param params.horizontalScrollPosition - Current horizontal scroll offset in pixels.
+     */
+    static drawScale(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        geneticTreeWidth: default_2;
+        horizontalScrollPosition: number;
+        pixelToGeneticDistanceRatio: number;
+        theme: Theme;
+        tickerMarkScale: TickerMarkScale;
+        zoomLevel: number;
+    }): void;
+    /**
+     * Renders the pre-assembled tree shapes onto a canvas using the 2D context.
+     *
+     * Applies a transform for zoom and scroll, then draws in order:
+     * vertical ancestor lines → horizontal ancestor lines → (linked) support lines
+     * → (highlighted) distance labels → ancestor dots → leaf branch lines → leaf dots.
+     *
+     * When nodes are highlighted, non-highlighted shapes are dimmed via the
+     * theme's `dimFn`. Leaf dot colours come from the stratification's `caseIdColors`
+     * when available.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.theme - MUI theme providing colours and font settings.
+     * @param params.treeAssembly - Pre-computed tree shapes from {@link assembleTree}.
+     * @param params.stratification - Colour mapping per case ID for leaf dots.
+     * @param params.zoomLevel - Current zoom level applied as a canvas transform.
+     * @param params.highlightedNodeNames - Node names to highlight; all others are dimmed.
+     * @param params.verticalScrollPosition - Vertical scroll offset in pixels.
+     * @param params.horizontalScrollPosition - Horizontal scroll offset in pixels.
+     * @param params.shouldShowDistances - Whether to render branch distance labels.
+     * @param params.devicePixelRatio - Screen DPR for crisp rendering on HiDPI displays.
+     * @param params.isLinked - Whether to draw the dashed support lines linking leaf nodes to the table.
+     * @param params.shouldShowSupportLinesWhenUnlinked - Whether to render support lines when unlinked.
+     */
+    static drawTree(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        externalRange: {
+            endIndex: number;
+            startIndex: number;
+        };
+        externalScrollPosition?: number;
+        headerHeight?: number;
+        highlightedNodeNames: string[];
+        horizontalScrollPosition: number;
+        isLinked: boolean;
+        itemHeight: number;
+        shouldShowDistances: boolean;
+        shouldShowSupportLinesWhenUnlinked: boolean;
+        stratification: Stratification;
+        theme: Theme;
+        treeAssembly: TreeAssembly;
+        verticalScrollPosition: number;
+        zoomLevel: number;
+    }): void;
+    /**
+     * Fully redraws the tree canvas from scratch.
+     *
+     * Resets the canvas, resizes it to match its CSS layout size at the current
+     * DPR, then sequentially calls {@link drawBackground}, {@link drawGuides},
+     * and {@link drawTree}.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.theme - MUI theme used for colours and fonts.
+     * @param params.treeAssembly - Pre-computed tree shapes from {@link assembleTree}.
+     * @param params.stratification - Colour mapping per case ID.
+     * @param params.zoomLevel - Current zoom level.
+     * @param params.isLinked - Whether to draw dashed support lines.
+     * @param params.highlightedNodeNames - Node names to highlight.
+     * @param params.verticalScrollPosition - Vertical scroll offset in pixels.
+     * @param params.horizontalScrollPosition - Horizontal scroll offset in pixels.
+     * @param params.treeCanvasWidth - Logical canvas width in pixels.
+     * @param params.treeCanvasHeight - Logical canvas height in pixels.
+     * @param params.pixelToGeneticDistanceRatio - Pixels per unit of genetic distance.
+     * @param params.tickerMarkScale - Scale tuple from {@link getTickMarkScale}.
+     * @param params.shouldShowDistances - Whether to render branch labels.
+     * @param params.shouldShowSupportLinesWhenUnlinked - Whether to render support lines when unlinked.
+     * @param params.devicePixelRatio - Screen DPR for HiDPI rendering.
+     * @param params.geneticTreeWidth - Total genetic width of the tree, used for guide lines.
+     */
+    static drawTreeCanvas(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        externalRange: {
+            endIndex: number;
+            startIndex: number;
+        };
+        externalScrollPosition?: number;
+        geneticTreeWidth: default_2;
+        headerHeight?: number;
+        highlightedNodeNames?: string[];
+        horizontalScrollPosition: number;
+        isLinked: boolean;
+        itemHeight: number;
+        pixelToGeneticDistanceRatio: number;
+        shouldShowDistances: boolean;
+        shouldShowSupportLinesWhenUnlinked: boolean;
+        stratification: Stratification;
+        theme: Theme;
+        tickerMarkScale: TickerMarkScale;
+        treeAssembly: TreeAssembly;
+        treeCanvasHeight: number;
+        treeCanvasWidth: number;
+        verticalScrollPosition: number;
+        zoomLevel: number;
+    }): void;
+    /**
+     * Finds and returns a new root node for re-rooting the tree.
+     *
+     * When `selector` is `'node'`, the node with the given name becomes the new root.
+     * When `selector` is `'parent'`, the parent of the node with the given name is returned.
+     *
+     * The returned node has its `branchLength` reset to `0` and its `maxBranchLength`
+     * adjusted by subtracting the original branch length, so the scale remains consistent.
+     *
+     * @param rootNode - The current root of the tree.
+     * @param nodeName - Name of the node to search for.
+     * @param selector - Whether to return the matching node itself (`'node'`) or its parent (`'parent'`).
+     * @returns A shallow copy of the new root with adjusted branch length properties.
+     */
+    static findNewTreeRoot(rootNode: TreeNode, nodeName: string, selector: 'node' | 'parent'): TreeNode;
+    /**
+     * Finds the smallest non-zero branch length among all leaf nodes in the tree.
+     *
+     * This value is used as the minimum scale unit when computing tick mark
+     * intervals, ensuring the scale never subdivides below a single measurable step.
+     *
+     * @param tree - The root node of the tree to inspect.
+     * @returns The minimum positive branch length found on any leaf, or `Infinity`
+     *   if the tree is empty or all leaves have zero/undefined branch lengths.
+     */
+    static getMinGeneticScaleUnit(tree: TreeNode): number;
+    /**
+     * Calculates the new scroll position after a zoom level change so that the
+     * point under the cursor stays in the same visual position.
+     *
+     * @param params.eventOffset - Pixel offset of the zoom event (e.g. mouse position) within the canvas.
+     * @param params.scrollPosition - Current scroll position before the zoom change.
+     * @param params.dimensionSize - Full logical size of the scrollable dimension in pixels.
+     * @param params.currentZoomLevel - The zoom level before the change.
+     * @param params.newZoomLevel - The zoom level after the change.
+     * @returns The adjusted scroll position that keeps the cursor-point visually stable.
+     */
+    static getNewScrollPositionForZoomLevel(params: {
+        currentZoomLevel: number;
+        dimensionSize: number;
+        eventOffset: number;
+        newZoomLevel: number;
+        scrollPosition: number;
+    }): number;
+    /**
+     * Performs a hit-test against the tree assembly's path maps to find the
+     * tree node or line segment under the mouse cursor.
+     *
+     * Checks in priority order: node dots (via `isPointInPath`) → horizontal
+     * branch lines (with ±1 px vertical tolerance) → vertical connector lines
+     * (with ±1 px horizontal tolerance).
+     *
+     * @param params.canvas - The canvas element that received the mouse event.
+     * @param params.event - The mouse event providing cursor coordinates.
+     * @param params.treeAssembly - The assembly containing path maps to hit-test against.
+     * @param params.devicePixelRatio - Screen DPR for correct coordinate scaling.
+     * @returns The {@link TreePathProperties} of the hit shape, or `undefined` if nothing was hit.
+     */
+    static getPathPropertiesFromCanvas(params: {
+        canvas: HTMLCanvasElement;
+        devicePixelRatio: number;
+        event: MouseEvent;
+        treeAssembly: TreeAssembly;
+    }): TreePathProperties;
+    /**
+     * Clamps X and Y scroll positions to their valid ranges for the current
+     * canvas dimensions, zoom level, and link state.
+     *
+     * When the tree is linked and at zoom level 1, y-scrolling is constrained
+     * tightly to the tree's pixel height. When unlinked or zoomed, the bounds
+     * include the full canvas extent to allow free panning.
+     *
+     * Also applies a device-pixel-ratio-dependent correction offset to prevent
+     * subtle over-scroll artefacts at non-integer DPR values (e.g. browser zoom).
+     *
+     * @param params.positionX - Requested horizontal scroll position.
+     * @param params.positionY - Requested vertical scroll position.
+     * @param params.treeCanvasWidth - Logical canvas width in pixels.
+     * @param params.treeCanvasHeight - Logical canvas height in pixels.
+     * @param params.treeHeight - Total rendered height of the full tree in pixels.
+     * @param params.devicePixelRatio - Current screen DPR.
+     * @param params.internalZoomLevel - Internal zoom level of the tree canvas.
+     * @param params.isLinked - Whether the tree is linked to the case list scroll position.
+     * @returns Clamped `{ newPositionX, newPositionY }` values.
+     */
+    static getSanitizedScrollPosition(params: {
+        devicePixelRatio: number;
+        internalZoomLevel: number;
+        isLinked: boolean;
+        positionX: number;
+        positionY: number;
+        treeCanvasHeight: number;
+        treeCanvasWidth: number;
+        treeHeight: number;
+    }): {
+        newPositionX: number;
+        newPositionY: number;
+    };
+    /**
+     * Calculates the vertical scroll position for a tree canvas based on the
+     * currently visible rows in a linked table/list view.
+     *
+     * The goal is to keep the visible portion of the tree centered on the same
+     * items that are currently visible in the linked view, accounting for zoom.
+     *
+     * @param kwArgs.treeCanvasHeight - Height of the visible tree canvas area in pixels.
+     * @param kwArgs.treeHeight - Total rendered height of the full tree in pixels.
+     * @param kwArgs.treeSize - Total number of leaf items (rows) in the tree.
+     * @param kwArgs.verticalScrollPosition - Current vertical scroll position of the linked view in pixels.
+     * @param kwArgs.zoomLevel - Current zoom level (>1 means zoomed out, items appear smaller).
+     * @returns The new vertical scroll position for the tree canvas, clamped to [0, treeHeight - treeCanvasHeight].
+     */
+    static getScrollPositionFromTreeVisibility(kwArgs: {
+        itemHeight: number;
+        treeCanvasHeight: number;
+        treeHeight: number;
+        treeSize: number;
+        verticalScrollPosition: number;
+        zoomLevel: number;
+    }): number;
+    /**
+     * Determines the optimal tick mark scale for the genetic distance axis.
+     *
+     * Selects the number of scale lines and the genetic distance represented by
+     * each interval by searching for the combination with the least leftover
+     * (i.e. the product of `numLines × increment` closest to `geneticTreeWidth`).
+     * Increments are drawn from `SCALE_INCREMENTS` scaled by an order-of-magnitude
+     * multiplier derived from `geneticTreeWidth`, and those smaller than
+     * `minGeneticScaleUnit` are skipped.
+     *
+     * @param params.treeWidthMinusPadding - Width of the drawable canvas area in pixels (excluding padding).
+     * @param params.geneticTreeWidth - Total genetic distance represented by the full tree width.
+     * @param params.minGeneticScaleUnit - The smallest meaningful genetic distance unit (see {@link getMinGeneticScaleUnit}).
+     * @param params.zoomLevel - Current zoom level; divides the effective pixel width.
+     * @returns A {@link TickerMarkScale} tuple: `[numberOfLines, geneticDistancePerLine, minGeneticScaleUnit]`.
+     *   Returns `[0, 0, 0]` when any required input is falsy.
+     */
+    static getTickMarkScale(params: {
+        geneticTreeWidth: default_2;
+        minGeneticScaleUnit: number;
+        treeWidthMinusPadding: number;
+        zoomLevel: number;
+    }): TickerMarkScale;
+    /**
+     * Produces a stable, unique string ID for a tree configuration by
+     * concatenating the IDs of its column, reference column, genetic distance
+     * protocol, and tree algorithm.
+     *
+     * @param treeConfiguration - The configuration to identify (without a pre-existing `computedId`).
+     * @returns A string of the form `"colId_refColId_protocolId_algorithmId"`.
+     */
+    static getTreeConfigurationId(treeConfiguration: Omit<TreeConfiguration, 'computedId'>): string;
+    /**
+     * Returns a human-readable display label for a tree configuration.
+     *
+     * @param config - The tree configuration to label.
+     * @returns A string of the form `"<protocolName> - <algorithmName>"`.
+     */
+    static getTreeConfigurationLabel(config: TreeConfiguration): string;
+    /**
+     * Derives all possible tree configurations for the given case type.
+     *
+     * Iterates over all columns of type `GENETIC_DISTANCE`, then for each column
+     * produces one {@link TreeConfiguration} per available tree algorithm.
+     * Algorithms are sorted by their canonical order from `EpiDataManager`.
+     *
+     * @param completeCaseType - The fully-loaded case type containing columns,
+     *   reference columns, genetic distance protocols, and tree algorithms.
+     * @returns An array of tree configurations, one per (column × algorithm) pair.
+     */
+    static getTreeConfigurations(completeCaseType: CaseDbCompleteCaseType): TreeConfiguration[];
+    /**
+     * Sanitizes the tree by collapsing intermediate ancestor nodes that have a
+     * zero branch length, hoisting their children up to the parent level.
+     *
+     * This normalises Newick-parsed trees where polytomies or zero-distance
+     * internal nodes would otherwise produce visually redundant branching points.
+     *
+     * @param rootNode - The root of the tree to sanitize. Mutated in place.
+     * @returns The sanitized root node.
+     */
+    static sanitizeTree(rootNode: TreeNode): TreeNode;
+    /**
+     * Assembles the visual elements for an ancestor (internal) node and appends
+     * them to the tree assembly.
+     *
+     * Produces: vertical connector lines from each child toward the ancestor's
+     * Y midpoint (split into two sorted groups above and below center to allow
+     * per-segment highlighting), a horizontal branch line, an optional distance
+     * label, and a filled dot when all children have positive branch lengths.
+     *
+     * @param treeAssemblyContext - Shared context holding the assembly target and canvas dimensions.
+     * @param node - The ancestor tree node to assemble.
+     * @param childRenderResults - Assembly results returned by all direct children.
+     * @returns The pixel coordinates of the branch start and aggregated case IDs, for use by the parent.
+     */
+    private static assembleAncestorNode;
+    /**
+     * Assembles the visual elements for a single leaf node and appends them to
+     * the tree assembly.
+     *
+     * Produces: a horizontal branch line, an optional distance label, a dashed
+     * support line extending to the canvas edge, and a filled dot.
+     *
+     * @param treeAssemblyContext - Shared context holding the assembly target and canvas dimensions.
+     * @param node - The leaf tree node to assemble.
+     * @param distance - Accumulated genetic distance from the root to the start of this node's branch.
+     * @param leafIndex - Zero-based vertical index of this leaf, determining its Y position.
+     * @param externalSortingIndex - External sorting index of this leaf derived from linked view order. Used to draw the support line.
+     * @returns The pixel coordinates of the branch start and the node name, for use by the parent.
+     */
+    private static assembleLeafNode;
+    /**
+     * Helper that wraps a canvas drawing callback with a DPR-aware scale/translate
+     * transform, then restores the context to its pre-call state.
+     *
+     * @param canvas - The canvas element whose 2D context to use.
+     * @param devicePixelRatio - Screen DPR to scale up for HiDPI rendering.
+     * @param callback - Drawing operations to perform inside the transform.
+     */
+    private static draw;
+    /**
+     * Fills the tree canvas background with the theme's paper colour.
+     *
+     * @param params.canvas - The canvas element to draw onto.
+     * @param params.theme - MUI theme providing the background colour.
+     * @param params.treeCanvasWidth - Width of the area to fill in pixels.
+     * @param params.treeCanvasHeight - Height of the area to fill in pixels.
+     * @param params.devicePixelRatio - Screen DPR for HiDPI rendering.
+     */
+    private static drawBackground;
+    /**
+     * Iterates over each scale line position and invokes a callback with its
+     * canvas X coordinate.
+     *
+     * Computes the pixel offset for each tick so that the rightmost line aligns
+     * with the genetic tree width, accounting for the current scroll and zoom.
+     *
+     * @param params.tickerMarkScale - Scale tuple from {@link getTickMarkScale}.
+     * @param params.geneticTreeWidth - Total genetic width of the tree.
+     * @param params.pixelToGeneticDistanceRatio - Pixels per unit of genetic distance.
+     * @param params.zoomLevel - Current zoom level.
+     * @param params.devicePixelRatio - Screen DPR.
+     * @param params.horizontalScrollPosition - Current horizontal scroll offset in pixels (default 0).
+     * @param params.callback - Called for each line with `(x, index, numberOfLines)`.
+     */
+    private static forEachScaleLine;
+    private static getCanvasContext;
+    /**
+     * Returns a formatted distance label string for a branch, or `null` if the
+     * label should be suppressed.
+     *
+     * A label is suppressed when:
+     * - The tree has no maximum branch length, or it is zero.
+     * - The branch length is zero or undefined.
+     * - The branch is shorter than `MINIMUM_DISTANCE_PERCENTAGE_TO_SHOW_LABEL`
+     *   percent of the maximum branch length in the tree.
+     *
+     * Precision is derived from the magnitude of `maxBranchLength` to avoid
+     * excessive decimal places for large values.
+     *
+     * @param treeAssemblyContext - Context containing the root node (for `maxBranchLength`).
+     * @param branchLength - The genetic distance of the branch to label.
+     * @returns A rounded numeric string, or `null` if the label should be hidden.
+     */
+    private static getDistanceLabel;
+    /**
+     * Returns the fill/stroke colour for a shape, dimming it when highlighted
+     * nodes are active and the shape is not among them.
+     *
+     * @param color - The full-brightness colour to use when highlighted or no highlight is active.
+     * @param dimFn - A function that returns a dimmed version of the colour.
+     * @param highlightedNodeNames - The currently highlighted node names.
+     * @param nodeNames - The node name(s) associated with the shape being drawn.
+     * @returns The resolved colour string.
+     */
+    private static getFillStyle;
+}
+
+export declare const EpiTreeWidget: ({ itemHeight, lineListRangeSubject, linkedScrollSubject, ref }: EpiTreeWidgetProps) => JSX.Element;
+
+declare interface EpiTreeWidgetData extends WidgetData {
+    horizontalScrollPosition: number;
+    treeConfiguration: TreeConfiguration;
+    verticalScrollPosition: number;
+    zoomLevel: number;
+}
+
+declare type EpiTreeWidgetProps = {
+    readonly itemHeight: number;
+    readonly lineListRangeSubject: Subject<EpiLineListRangeSubjectValue>;
+    readonly linkedScrollSubject: Subject<EpiLinkedScrollSubjectValue>;
+    readonly ref: Ref<EpiTreeWidgetRef>;
+};
+
+export declare interface EpiTreeWidgetRef {
+    link: () => void;
+}
+
+export declare const EpiUpload: () => JSX.Element;
+
+export declare type EpiUploadCompleteColStats = {
+    readsColumns: CaseDbCol[];
+    sampleIdColumns: CaseDbCol[];
+    sequenceColumns: CaseDbCol[];
+    writableColumns: CaseDbCol[];
+};
+
+/**
+ * File assignment result for genetic file uploads
+ */
+export declare interface EpiUploadFileColumnAssignment {
+    col: CaseDbCol;
+    file: File;
+}
+
+export declare type EpiUploadMappedColumn = {
+    col: CaseDbCol;
+    isCaseIdColumn?: boolean;
+    isCol?: boolean;
+    isSampleIdColumn?: boolean;
+    originalIndex: number;
+    originalLabel: string;
+    sampleIdentifierIssuerId?: string;
+};
+
+export declare type EpiUploadMappedColumnsFormFields = {
+    [key: string]: string;
+};
+
+export declare type EpiUploadSequenceMapping = {
+    [caseId: string]: EpiUploadSequenceMappingForCaseId;
+};
+
+export declare type EpiUploadSequenceMappingForCaseId = {
+    readsFileNames: {
+        [colId: string]: {
+            fwd: string;
+            rev: string;
+        };
+    };
+    sequenceFileNames: {
+        [colId: string]: string;
+    };
+};
+
+export declare type EpiUploadStore = EpiUploadStoreActions & EpiUploadStoreState;
+
+export declare interface EpiUploadStoreActions {
+    destroy: () => Promise<void>;
+    findNextStep: (currentStep: EPI_UPLOAD_STEP) => EPI_UPLOAD_STEP;
+    findPreviousStep: (currentStep: EPI_UPLOAD_STEP) => EPI_UPLOAD_STEP;
+    goToNextStep: () => Promise<void>;
+    goToPreviousStep: () => void;
+    invalidateCaseValidationQuery: () => Promise<void>;
+    reset: () => Promise<void>;
+    setCaseTypeId: (caseTypeId: string) => void;
+    setCols: (cols: CaseDbCol[]) => void;
+    setCompleteCaseType: (completeCaseType: CaseDbCompleteCaseType) => void;
+    setCreatedInDataCollectionId: (createdInDataCollectionId: string) => void;
+    setDataCollectionOptions: (options: OptionBase<string>[]) => void;
+    setFileList: (fileList: FileList) => Promise<void>;
+    setMappedColumns: (mappedColumns: EpiUploadMappedColumn[]) => Promise<void>;
+    setRawData: (rawData: string[][]) => Promise<void>;
+    setSequenceFilesDataTransfer: (dataTransfer: DataTransfer) => void;
+    setSequenceMapping: (sequenceMapping: EpiUploadSequenceMapping) => void;
+    setSheet: (sheet: string) => Promise<void>;
+    setSheetOptions: (sheetOptions: AutoCompleteOption<string>[]) => Promise<void>;
+    setValidatedCases: (validatedCases: CaseDbCaseUploadResult[]) => void;
+}
+
+export declare const EpiUploadStoreContext: Context<StoreApi<EpiUploadStore>>;
+
+export declare interface EpiUploadStoreState {
+    activeStep: EPI_UPLOAD_STEP;
+    assemblyProtocolId: string;
+    caseTypeId: string;
+    cols: CaseDbCol[];
+    completeCaseType: CaseDbCompleteCaseType;
+    createdInDataCollectionId: string;
+    createdInDataCollectionOptions: AutoCompleteOption<string>[];
+    dataCollectionOptions: OptionBase<string>[];
+    fileList: FileList;
+    fileName: string;
+    fileParsingError: string;
+    initError: unknown;
+    isInitLoading: boolean;
+    mappedColumns: EpiUploadMappedColumn[];
+    rawData: string[][];
+    sampleIdColId: string;
+    sequenceFilesDataTransfer: DataTransfer;
+    sequenceMapping: EpiUploadSequenceMapping;
+    sequencingProtocolId: string;
+    sheet: string;
+    sheetOptions: AutoCompleteOption<string>[];
+    shouldResetColumnMapping: boolean;
+    shouldResetSequenceMapping: boolean;
+    validateCasesQueryKey: string[];
+    validatedCases: CaseDbCaseUploadResult[];
+    validatedCasesWithGeneratedId: CaseUploadResultWithGeneratedId[];
+}
+
+export declare type EpiUploadTableRow = {
+    [key: string]: string;
+};
+
+export declare class EpiUploadUtil {
+    static readonly caseDateColumnAliases: string[];
+    static readonly caseIdColumnAliases: string[];
+    static readonly colAliases: string[];
+    static areMappedColumnsEqual(a: EpiUploadMappedColumn[], b: EpiUploadMappedColumn[]): boolean;
+    static createCases(kwArgs: {
+        assemblyProtocolId: string;
+        caseTypeId: string;
+        completeCaseType: CaseDbCompleteCaseType;
+        createdInDataCollectionId: string;
+        mappedColumns: EpiUploadMappedColumn[];
+        sampleIdColId: string;
+        sequenceMapping: EpiUploadSequenceMapping;
+        sequencingProtocolId: string;
+        signal: AbortSignal;
+        validatedCases: CaseDbCaseUploadResult[];
+        validatedCasesWithGeneratedId: CaseUploadResultWithGeneratedId[];
+    }): Promise<CaseDbCaseBatchUploadResult>;
+    static createCasesAndUploadFiles(kwArgs: {
+        assemblyProtocolId: string;
+        caseTypeId: string;
+        completeCaseType: CaseDbCompleteCaseType;
+        createdInDataCollectionId: string;
+        mappedColumns: EpiUploadMappedColumn[];
+        onComplete: () => void;
+        onError: (error: Error) => void;
+        onProgress: (progress: number, message: string) => void;
+        sampleIdColId: string;
+        sequenceFilesDataTransfer: DataTransfer;
+        sequenceMapping: EpiUploadSequenceMapping;
+        sequencingProtocolId: string;
+        signal: AbortSignal;
+        validatedCases: CaseDbCaseUploadResult[];
+        validatedCasesWithGeneratedId: CaseUploadResultWithGeneratedId[];
+    }): Promise<void>;
+    static getCasesForVerification(kwArgs: {
+        caseTypeId: string;
+        createdInDataCollectionId: string;
+        mappedColumns: EpiUploadMappedColumn[];
+        rawData: string[][];
+    }): CaseDbCaseForUpload[];
+    static getCaseTypeFromColumnLabels(cols: CaseDbCol[], columnLabels: string[]): CaseDbCaseType;
+    static getColumnMappingFormFieldDefinitions(completeCaseType: CaseDbCompleteCaseType, rawDataHeaders: string[], _fileName: string): FormFieldDefinition<EpiUploadMappedColumnsFormFields>[];
+    static getColumnMappingSchema(rawData: string[][], completeCaseType: CaseDbCompleteCaseType): ObjectSchema<{}, AnyObject, {}, ''>;
+    static getCompleteCaseTypeColStats(completeCaseType: CaseDbCompleteCaseType): EpiUploadCompleteColStats;
+    static getDefaultColumnMappingFormValues(rawDataHeaders: string[], mappedColumns: EpiUploadMappedColumn[], identifierIssuerOptions: OptionBase<string>[]): EpiUploadMappedColumnsFormFields;
+    static getEpiUploadSequenceMapping(completeCaseType: CaseDbCompleteCaseType, validatedCases: CaseUploadResultWithGeneratedId[], sequenceFilesDataTransfer: DataTransfer): EpiUploadSequenceMapping;
+    static getInitialMappedColumns(completeCaseType: CaseDbCompleteCaseType, rawData: string[][]): EpiUploadMappedColumn[];
+    static getMappedColumnsFromFormData(data: EpiUploadMappedColumnsFormFields, rawData: string[][], colMap: Map<string, CaseDbCol>, completeCaseType: CaseDbCompleteCaseType): EpiUploadMappedColumn[];
+    static getSampleIdColIds(completeCaseType: CaseDbCompleteCaseType): string[];
+    static getSequenceMappingStats(sequenceMapping: EpiUploadSequenceMapping, sequenceFilesDataTransfer: DataTransfer): {
+        mappedFiles: string[];
+        mappedReadsFiles: string[];
+        mappedSequenceFiles: string[];
+        numberOfFilesToMap: number;
+        unmappedFileNames: string[];
+        unmappedReadsFiles: string[];
+        unmappedSequenceFiles: string[];
+    };
+    static getSheetNameOptions(fileList: FileList): Promise<AutoCompleteOption<string>[]>;
+    static hasReadsColumnMapped(mappedColumns: EpiUploadMappedColumn[], completeCaseTypeColStats: EpiUploadCompleteColStats): boolean;
+    static hasSequenceColumnMapped(mappedColumns: EpiUploadMappedColumn[], completeCaseTypeColStats: EpiUploadCompleteColStats): boolean;
+    static isCaseDateColumn(label: string): boolean;
+    static isCaseIdColumn(label: string): boolean;
+    static isCol(label: string): boolean;
+    static isGenomeFile(fileName: string): boolean;
+    static isReadsFile(fileName: string): boolean;
+    static isSupportedGeneticFile(fileName: string): boolean;
+    static isTextFile(fileName: string): boolean;
+    static isXlsxFile(fileName: string): boolean;
+    static matchColumnLabel(columnLabel: string, col: CaseDbCol): boolean;
+    static readFileAsBase64(file: File): Promise<string>;
+    static readRawData(fileList: FileList, sheet?: string): Promise<string[][]>;
+    static reportFileUploadProgress(kwArgs: {
+        endPercentage: number;
+        fileSize: number;
+        message: string;
+        onProgress: (progress: number, message: string) => void;
+        startPercentage: number;
+        totalFileSizeToUpload: number;
+        uploadedFileSize: number;
+    }): void;
+    static uploadFilesForCases(kwArgs: {
+        assemblyProtocolId: string;
+        caseBatchUploadResult: CaseDbCaseBatchUploadResult;
+        caseTypeId: string;
+        completeCaseType: CaseDbCompleteCaseType;
+        createdInDataCollectionId: string;
+        endPercentage: number;
+        mappedColumns: EpiUploadMappedColumn[];
+        onComplete: () => void;
+        onError: (error: Error) => void;
+        onProgress: (progress: number, message: string) => void;
+        sampleIdColId: string;
+        sequenceFilesDataTransfer: DataTransfer;
+        sequenceMapping: EpiUploadSequenceMapping;
+        sequencingProtocolId: string;
+        signal: AbortSignal;
+        startPercentage: number;
+        validatedCases: CaseDbCaseUploadResult[];
+        validatedCasesWithGeneratedId: CaseUploadResultWithGeneratedId[];
+    }): Promise<void>;
+    private static idToRegex;
+    private static mapExcelCellToString;
+    private static mapExcelSheetData;
+}
+
+export declare const EpiUserRightsDialog: ComponentClass<EpiUserRightsDialogProps, WithDialogState<EpiUserRightsDialogOpenProps>>;
+
+export declare interface EpiUserRightsDialogOpenProps {
+    user: CaseDbUser;
+}
+
+export declare interface EpiUserRightsDialogProps extends WithDialogRenderProps<EpiUserRightsDialogOpenProps> {
+}
+
+export declare type EpiUserRightsDialogRefMethods = WithDialogRefMethods<EpiUserRightsDialogProps, EpiUserRightsDialogOpenProps>;
+
+export declare const EpiWarning: ({ warningMessage }: EpiWarningProps) => JSX.Element;
+
+export declare type EpiWarningProps = {
+    readonly warningMessage: string;
+};
+
+export declare const EpiWidget: ({ children, expandDisabled, isLoading, primaryMenu, secondaryMenu, title, warningMessage, zone }: WidgetProps) => JSX.Element;
+
+export declare const EpiWidgetMenu: ({ menu, }: EpiWidgetMenuProps) => JSX.Element;
+
+export declare type EpiWidgetMenuProps = {
+    readonly menu: MenuItemData[] | ReactNode;
+};
+
+export declare const EpiWidgetUnavailable: ({ epiZone, widgetName }: EpiWidgetUnavailableProps) => JSX.Element;
+
+export declare type EpiWidgetUnavailableProps = {
+    readonly epiZone: EPI_ZONE;
+    readonly widgetName: string;
+};
+
+export declare const EtiologicalAgentsAdminPage: () => JSX.Element;
+
+export declare const EtiologiesAdminPage: () => JSX.Element;
+
+export declare const EventsDetailPage: () => JSX.Element;
+
+export declare const EventsPage: () => JSX.Element;
+
+export declare const FileSelector: ({ accept, initialDataTransfer: initialDataTransferProp, numFilesAllowed, onDataTransferChange, }: FileSelectorProps) => JSX.Element;
+
+export declare type FileSelectorProps = {
+    readonly accept: string;
+    readonly initialDataTransfer?: DataTransfer;
+    readonly numFilesAllowed?: number;
+    readonly onDataTransferChange: (dataTransfer: DataTransfer) => void;
+};
+
+export declare class FileUtil {
+    static getFileCompressionFromFileName(fileName: string): CaseDbFileCompression;
+    static getReadableFileSize(sizeInBytes: number): string;
+}
+
+export declare enum FILTER_TYPE {
+    DATE = "DATE",
+    GEO = "GEO",
+    MULTI_SELECT = "MULTI_SELECT",
+    NUMBER = "NUMBER",
+    STRING = "STRING"
+}
+
+export declare type FindSimilarCasesResult = {
+    colId: string;
+    distance: number;
+    key: string;
+    originalCaseIds: string[];
+    similarCaseIds: string[];
+};
+
+export declare interface GenEpixCaseDbUiTheme extends GenEpixUiTheme {
+    'gen-epix-ui-casedb': {
+        lineList: {
+            font: string;
+            fontVariationSettings?: string;
+        };
+        tree: {
+            color: string;
+            dimFn: (color: string) => string;
+            font: string;
+            fontVariationSettings?: string;
+            supportLineColorLinked: string;
+            supportLineColorUnlinked: string;
+        };
+    };
+}
+
+declare type GetOrganizationPolicyGroupsKwArgs = Pick<AssembleUserEffectiveRightsKwArgs, 'organizationAccessCasePolicies' | 'organizationShareCasePolicies'>;
+
+export declare type Highlighting = {
+    caseIds: string[];
+    origin: EPI_ZONE;
+};
+
+export declare const HomePage: () => JSX.Element;
+
+export declare const HomePageTrends: {
+    (props: Record<string, never>): JSX.Element;
+    displayName: string;
+};
+
+declare interface Item {
+    date: Date;
+    row: CaseDbCase;
+    value: number;
+}
+
+export declare class NewickUtil {
+    static getSortedNames(node: TreeNode): string[];
+    static parse(newick: string): TreeNode;
+}
+
+export declare const OrganizationAccessCasePoliciesAdminPage: () => JSX.Element;
+
+export declare type OrganizationPolicyGroup = {
+    access_case_policies: CaseDbOrganizationAccessCasePolicy[];
+    data_collection_id: string;
+    organization_id: string;
+    share_case_policies: CaseDbOrganizationShareCasePolicy[];
+};
+
+export declare const OrganizationShareCasePoliciesAdminPage: () => JSX.Element;
+
+export declare const PhylogeneticTreeComponent: ({ ariaLabel, externalScrollSubject, externalVisibleRangeSubject, highlightingSubject, initialViewState, itemHeight, leafOrder, onCanvasChange, onLinkStateChange, onPathClick, onViewStateChange, ref, shouldShowDistances, shouldShowSupportLinesWhenUnlinked, stratification, tree, }: PhylogeneticTreeComponentProps) => JSX.Element;
+
+export declare type PhylogeneticTreeComponentPathClickEvent = {
+    mouseEvent: MouseEvent;
+    pathProperties: TreePathProperties;
+};
+
+export declare type PhylogeneticTreeComponentProps = {
+    readonly ariaLabel: string;
+    readonly externalScrollSubject?: Subject<EpiLinkedScrollSubjectValue>;
+    readonly externalVisibleRangeSubject?: Subject<EpiLineListRangeSubjectValue>;
+    readonly highlightingSubject?: Subject<Highlighting>;
+    readonly initialViewState?: Partial<PhylogeneticTreeComponentViewState>;
+    readonly itemHeight: number;
+    readonly leafOrder: string[];
+    readonly onCanvasChange?: (canvas?: HTMLCanvasElement) => void;
+    readonly onLinkStateChange?: (isLinked: boolean) => void;
+    readonly onPathClick?: (event: PhylogeneticTreeComponentPathClickEvent) => void;
+    readonly onViewStateChange?: (viewState: PhylogeneticTreeComponentViewState) => void;
+    readonly ref?: Ref<PhylogeneticTreeComponentRef>;
+    readonly shouldShowDistances: boolean;
+    readonly shouldShowSupportLinesWhenUnlinked: boolean;
+    readonly stratification?: Stratification;
+    readonly tree?: TreeNode;
+};
+
+export declare interface PhylogeneticTreeComponentRef {
+    link: (verticalPosition?: number) => void;
+    syncExternalScrollToVisibleTree: () => void;
+    unlink: (viewState: {
+        positionX: number;
+        positionY: number;
+        zoomLevel: number;
+    }) => void;
+}
+
+export declare type PhylogeneticTreeComponentViewState = {
+    horizontalScrollPosition: number;
+    verticalScrollPosition: number;
+    zoomLevel: number;
+};
+
+export declare const RefColsAdminPage: () => JSX.Element;
+
+export declare const RefDimsAdminPage: () => JSX.Element;
+
+export declare const RegionRelationsAdminPage: () => JSX.Element;
+
+export declare const regionRelationTypePresentationValues: Partial<Record<CaseDbRegionRelationType, string>>;
+
+export declare const RegionsAdminPage: () => JSX.Element;
+
+export declare const RegionSetsAdminPage: () => JSX.Element;
+
+export declare const RegionSetShapesAdminPage: () => JSX.Element;
+
+export declare type RegionStatistics = {
+    maxNumCases: number;
+    minNumCases: number;
+    numCases: number;
+    statisticsPerRegion: Record<string, {
+        numCases: number;
+        region: CaseDbRegion;
+        rows: CaseDbCase[];
+    }>;
+};
+
+declare type RoutePermission = CaseDbApiPermission | CommonDbApiPermission;
+
+declare type RoutePermission_2 = CaseDbApiPermission | CommonDbApiPermission;
+
+export declare const SELECTION_FILTER_GROUP = "selection";
+
+export declare const setupCaseDb: () => void;
+
+export declare const STEP_ORDER: EPI_UPLOAD_STEP[];
+
+declare interface StratifiableColumn {
+    col: CaseDbCol;
+    enabled: boolean;
+}
+
+export declare type Stratification = {
+    caseIdColors: {
+        [key: string]: string;
+    };
+    col?: CaseDbCol;
+    legendaItems?: StratificationLegendaItem[];
+    legendaItemsByColor?: {
+        [key: string]: StratificationLegendaItem;
+    };
+    legendaItemsByValue?: {
+        [key: string]: StratificationLegendaItem;
+    };
+    mode: STRATIFICATION_MODE;
+};
+
+export declare enum STRATIFICATION_MODE {
+    FIELD = "FIELD",
+    SELECTION = "SELECTION"
+}
+
+export declare enum STRATIFICATION_SELECTED {
+    SELECTED = "SELECTED",
+    UNSELECTED = "UNSELECTED"
+}
+
+export declare type StratificationLegendaItem = {
+    caseIds: string[];
+    color: string;
+    columnType?: CaseDbColType;
+    rowValue: CaseTypeRowValue;
+};
+
+declare type TickerMarkScale = [number, number, number];
+
+export declare const TREE_FILTER_GROUP = "tree";
+
+export declare const treeAlgorithmCodeValues: Record<CaseDbTreeAlgorithmType, string>;
+
+export declare type TreeAssembly = {
+    ancestorNodes: Array<{
+        nodeNames: string[];
+        shape: Path2D;
+    }>;
+    distanceTexts: Array<{
+        nodeNames: string[];
+        text: string;
+        x: number;
+        y: number;
+    }>;
+    horizontalAncestorTreeLines: Array<{
+        nodeNames: string[];
+        shape: Path2D;
+    }>;
+    horizontalLinePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+    leafNodes: Array<{
+        nodeName: string;
+        shape: Path2D;
+    }>;
+    leafTreeLines: Array<{
+        nodeName: string;
+        shape: Path2D;
+    }>;
+    nodePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+    supportLines: Array<{
+        fromX: number;
+        fromY: number;
+        nodeName: string;
+        toX: number;
+        toY: number;
+    }>;
+    verticalAncestorTreeLines: Array<{
+        nodeNames: string[];
+        shape: Path2D;
+    }>;
+    verticalLinePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+};
+
+declare type TreeAssemblyPathPropertiesMap = Map<Path2D, TreePathProperties>;
+
+export declare type TreeConfiguration = {
+    col: CaseDbCol;
+    computedId: string;
+    geneticDistanceProtocol: CaseDbGeneticDistanceProtocol;
+    refCol: CaseDbRefCol;
+    treeAlgorithm: CaseDbTreeAlgorithm;
+};
+
+export declare type TreeFocus = {
+    leafs: string[];
+    root: string;
+};
+
+export declare type TreeNode = {
+    address?: string;
+    branchLength?: default_2;
+    children?: TreeNode[];
+    maxBranchLength?: default_2;
+    name?: string;
+    size?: number;
+    subTreeLeaveNames?: string[];
+    subTreeNames?: string[];
+};
+
+export declare type TreePathProperties = {
+    subTreeLeaveNames: string[];
+    treeNode?: TreeNode;
+};
+
+export declare const TrendsPage: () => JSX.Element;
+
+export declare class UploadError extends Error {
+    caseBatchUploadResult: CaseDbCaseBatchUploadResult;
+    constructor(message: string, caseBatchUploadResult: CaseDbCaseBatchUploadResult);
+}
+
+export declare const UploadPage: () => JSX.Element;
+
+export declare const useAssemblyProtocolMapQuery: () => UseMap<CaseDbProtocol>;
+
+export declare const useAssemblyProtocolOptionsQuery: () => UseOptions<string>;
+
+export declare const useAssemblyProtocolsQuery: () => UseQueryResult<CaseDbProtocol[]>;
+
+export declare const useCaseAbacContext: () => CaseAbacContext;
+
+export declare const useCaseRightsQuery: (caseIds: string[], caseTypeId: string) => UseQueryResult<CaseDbCaseRights[]>;
+
+export declare const useCaseSetCategoriesQuery: () => UseQueryResult<CaseDbCaseSetCategory[]>;
+
+export declare const useCaseSetCategoryMapQuery: () => UseMap<CaseDbCaseSetCategory>;
+
+export declare const useCaseSetCategoryOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseSetOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseSetRightsQuery: (caseSetIds: string[]) => UseQueryResult<CaseDbCaseSetRights[]>;
+
+export declare const useCaseSetsMapQuery: () => UseMap<CaseDbCaseSet>;
+
+export declare const useCaseSetsQuery: () => UseQueryResult<CaseDbCaseSet[]>;
+
+export declare const useCaseSetStatsMapQuery: (caseSetIds: string[]) => UseMap<CaseDbCaseStats>;
+
+export declare const useCaseSetStatsQuery: (caseSetIds: string[]) => UseQueryResult<CaseDbCaseStats[]>;
+
+export declare const useCaseSetStatusesQuery: () => UseQueryResult<CaseDbCaseSetStatus[]>;
+
+export declare const useCaseSetStatusMapQuery: () => UseMap<CaseDbCaseSetStatus>;
+
+export declare const useCaseSetStatusOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseTypeAbacContext: () => CaseTypeAbacContext;
+
+export declare const useCaseTypeMapQuery: () => UseMap<CaseDbCaseType>;
+
+export declare const useCaseTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseTypeSetCategoriesQuery: () => UseQueryResult<CaseDbCaseTypeSetCategory[]>;
+
+export declare const useCaseTypeSetCategoryMapQuery: () => UseMap<CaseDbCaseTypeSetCategory>;
+
+export declare const useCaseTypeSetCategoryOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseTypeSetCategoryPurposeOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseTypeSetMembersQuery: () => UseQueryResult<CaseDbCaseTypeSetMember[]>;
+
+export declare const useCaseTypeSetNameFactory: () => UseNameFactory<CaseDbCaseTypeSet>;
+
+export declare const useCaseTypeSetOptionsQuery: () => UseOptions<string>;
+
+export declare const useCaseTypeSetsMapQuery: () => UseMap<CaseDbCaseTypeSet>;
+
+export declare const useCaseTypeSetsQuery: () => UseQueryResult<CaseDbCaseTypeSet[]>;
+
+export declare const useCaseTypesQuery: () => UseQueryResult<CaseDbCaseType[]>;
+
+export declare const useCaseTypeStatsQuery: (options?: CaseDbRetrieveCaseTypeStatsRequestBody) => UseQueryResult<CaseDbCaseStats[]>;
+
+export declare const useColMapQuery: () => UseMap<CaseDbCol>;
+
+export declare const useColNameFactory: () => UseNameFactory<CaseDbCol>;
+
+export declare const useColOptionsQuery: () => UseOptions<string>;
+
+export declare const useColSetMapQuery: () => UseMap<CaseDbColSet>;
+
+export declare const useColSetMembersQuery: () => UseQueryResult<CaseDbColSetMember[]>;
+
+export declare const useColSetOptionsQuery: () => UseOptions<string>;
+
+export declare const useColSetsQuery: () => UseQueryResult<CaseDbColSet[]>;
+
+export declare const useColsQuery: () => UseQueryResult<CaseDbCol[]>;
+
+export declare const useColTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useConceptMapQuery: () => UseMap<CaseDbConcept>;
+
+export declare const useConceptNameFactory: () => UseNameFactory<CaseDbConcept>;
+
+export declare const useConceptOptionsQuery: () => UseOptions<string>;
+
+export declare const useConceptQuery: () => UseQueryResult<CaseDbConcept[]>;
+
+export declare const useConceptRelationTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useConceptSetMapQuery: () => UseMap<CaseDbConceptSet>;
+
+export declare const useConceptSetOptionsQuery: () => UseOptions<string>;
+
+export declare const useConceptSetsQuery: () => UseQueryResult<CaseDbConceptSet[]>;
+
+export declare const useConceptSetTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useDataCollectionOptionsQuery: (dataCollectionIds?: string[]) => UseOptions<string>;
+
+export declare const useDataCollectionSetMembersQuery: () => UseQueryResult<CaseDbDataCollectionSetMember[]>;
+
+export declare const useDataCollectionsMapQuery: (dataCollectionIds?: string[]) => UseMap<CaseDbDataCollection>;
+
+export declare const useDataCollectionsQuery: (dataCollectionIds?: string[]) => UseQueryResult<CaseDbDataCollection[]>;
+
+export declare const useDimMapQuery: () => UseMap<CaseDbDim>;
+
+export declare const useDimNameFactory: () => UseNameFactory<CaseDbDim>;
+
+export declare const useDimOptionsQuery: () => UseOptions<string>;
+
+export declare const useDimsQuery: () => UseQueryResult<CaseDbDim[]>;
+
+export declare const useDimTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useDiseaseOptionsQuery: () => UseOptions<string>;
+
+export declare const useDiseasesMapQuery: () => UseMap<CaseDbDisease>;
+
+export declare const useDiseasesQuery: () => UseQueryResult<CaseDbDisease[]>;
+
+export declare const useEtiologicalAgentOptionsQuery: () => UseOptions<string>;
+
+export declare const useEtiologicalAgentsMapQuery: () => UseMap<CaseDbEtiologicalAgent>;
+
+export declare const useEtiologicalAgentsQuery: () => UseQueryResult<CaseDbEtiologicalAgent[]>;
+
+export declare const useGeneticDistanceProtocolOptionsQuery: () => UseOptions<string>;
+
+export declare const useGeneticDistanceProtocolsQuery: () => UseQueryResult<CaseDbGeneticDistanceProtocol[]>;
+
+export declare const useOrganizationAccessCasePoliciesQuery: (select?: (data: CaseDbOrganizationAccessCasePolicy[]) => CaseDbOrganizationAccessCasePolicy[]) => UseQueryResult<CaseDbOrganizationAccessCasePolicy[]>;
+
+export declare const useOrganizationCasePolicyNameFactory: () => UseNameFactory<CaseDbOrganizationAccessCasePolicy | CaseDbOrganizationShareCasePolicy>;
+
+export declare const useOrganizationShareCasePoliciesQuery: (select?: (data: CaseDbOrganizationShareCasePolicy[]) => CaseDbOrganizationShareCasePolicy[]) => UseQueryResult<CaseDbOrganizationShareCasePolicy[]>;
+
+export declare const UserAccessCasePoliciesAdminPage: () => JSX.Element;
+
+export declare const useRefColMapQuery: () => UseMap<CaseDbRefCol>;
+
+export declare const useRefColOptionsQuery: () => UseOptions<string>;
+
+export declare const useRefColsQuery: () => UseQueryResult<CaseDbRefCol[]>;
+
+export declare const useRefColsValidationRulesQuery: () => UseQueryResult<CaseDbRefColValidationRulesResponseBody>;
+
+export declare const useRefDimMapQuery: () => UseMap<CaseDbRefDim>;
+
+export declare const useRefDimOptionsQuery: () => UseOptions<string>;
+
+export declare const useRefDimsQuery: () => UseQueryResult<CaseDbRefDim[]>;
+
+export declare type UserEffectiveRight = {
+    readonly categorized_read_col_ids: string[];
+    readonly categorized_write_col_ids: string[];
+    readonly effective_share_case_rights: Array<Pick<CaseDbUserShareCasePolicy, 'add_case_set' | 'add_case' | 'from_data_collection_id' | 'remove_case_set' | 'remove_case'> & UserEffectiveRightCaseTypes>;
+    readonly read_col_set_ids: string[];
+    readonly uncategorized_read_col_ids: string[];
+    readonly uncategorized_write_col_ids: string[];
+    readonly write_col_set_ids: string[];
+} & Omit<CaseDbOrganizationAccessCasePolicy & CaseDbUserAccessCasePolicy, 'case_type_set_id' | 'id' | 'is_active' | 'user_id'> & UserEffectiveRightCaseTypes;
+
+export declare type UserEffectiveRightCaseTypes = {
+    readonly case_type_set_ids: string[];
+    readonly categorized_case_type_ids: string[];
+    readonly uncategorized_case_type_ids: string[];
+};
+
+export declare const UserEffectiveRightsAdminPage: () => JSX.Element;
+
+export declare type UserEffectiveRightsQueryResult = {
+    caseTypeSetMembers: CaseDbCaseTypeSetMember[];
+    colSetMembers: CaseDbColSetMember[];
+    colSetsMap: UseMap<CaseDbColSet>['map'];
+    effectiveRights: UserEffectiveRight[];
+    organizationAccessCasePolicies: CaseDbOrganizationAccessCasePolicy[];
+    organizationShareCasePolicies: CaseDbOrganizationShareCasePolicy[];
+    user: CaseDbUser;
+    userAccessCasePolicies: CaseDbUserAccessCasePolicy[];
+    userShareCasePolicies: CaseDbUserShareCasePolicy[];
+};
+
+export declare const UserEffectiveRightsTesterAdminPage: () => JSX.Element;
+
+export declare const useRegionMapQuery: () => UseMap<CaseDbRegion>;
+
+export declare const useRegionNameFactory: () => UseNameFactory<CaseDbRegion>;
+
+export declare const useRegionOptionsQuery: () => UseOptions<string>;
+
+export declare const useRegionQuery: () => UseQueryResult<CaseDbRegion[]>;
+
+export declare const useRegionRelationTypeOptionsQuery: () => UseOptions<string>;
+
+export declare const useRegionSetOptionsQuery: () => UseOptions<string>;
+
+export declare const useRegionSetsMapQuery: () => UseMap<CaseDbRegionSet>;
+
+export declare const useRegionSetsQuery: () => UseQueryResult<CaseDbRegionSet[]>;
+
+export declare type UserProfileStore = UserProfileStoreActions & UserProfileStoreState;
+
+export declare const userProfileStore: Omit<StoreApi<UserProfileStore>, "persist" | "setState"> & {
+    setState(partial: UserProfileStore | Partial<UserProfileStore> | ((state: UserProfileStore) => UserProfileStore | Partial<UserProfileStore>), replace?: false): unknown;
+    setState(state: UserProfileStore | ((state: UserProfileStore) => UserProfileStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<PersistOptions<UserProfileStore, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: UserProfileStore) => void) => () => void;
+        onFinishHydration: (fn: (state: UserProfileStore) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<UserProfileStore, unknown, unknown>>;
+    };
+};
+
+export declare interface UserProfileStoreActions {
+    resetEpiDashboardGeneralSettings: () => void;
+    resetEpiDashboardLayout: () => void;
+    resetEpiDashboardTreeSettings: () => void;
+    setEpiDashboardGeneralSettings: (settings: EpiDashboardGeneralSettings) => void;
+    setEpiDashboardLayoutUserConfig: (config: EpiDashboardLayoutUserConfig) => void;
+    setEpiDashboardPanelConfiguration: (id: string, configuration: string) => void;
+    setEpiDashboardTreeSettings: (settings: EpiDashboardTreeSettings) => void;
+}
+
+export declare interface UserProfileStoreState {
+    epiDashboardGeneralSettings: EpiDashboardGeneralSettings;
+    epiDashboardLayoutUserConfig: EpiDashboardLayoutUserConfig;
+    epiDashboardPanels: {
+        [key: string]: string;
+    };
+    epiDashboardTreeSettings: EpiDashboardTreeSettings;
+}
+
+export declare const UsersEffectiveRightsDetailsDialog: ComponentClass<UsersEffectiveRightsDetailsDialogProps, WithDialogState<UsersEffectiveRightsDetailsDialogOpenProps>>;
+
+export declare interface UsersEffectiveRightsDetailsDialogOpenProps {
+    type: 'caseTypeSets' | 'readColSets' | 'writeColSets';
+    user: CaseDbUser;
+    userEffectiveRight: UserEffectiveRight;
+}
+
+export declare interface UsersEffectiveRightsDetailsDialogProps extends WithDialogRenderProps<UsersEffectiveRightsDetailsDialogOpenProps> {
+}
+
+export declare type UsersEffectiveRightsDetailsDialogRefMethods = WithDialogRefMethods<UsersEffectiveRightsDetailsDialogProps, UsersEffectiveRightsDetailsDialogOpenProps>;
+
+export declare type UsersEffectiveRightsDetailsType = 'caseTypeSets' | 'readColSets' | 'writeColSets';
+
+export declare const UserShareCasePoliciesAdminPage: () => JSX.Element;
+
+export declare const useSequencingProtocolMapQuery: () => UseMap<CaseDbProtocol>;
+
+export declare const useSequencingProtocolOptionsQuery: () => UseOptions<string>;
+
+export declare const useSequencingProtocolsQuery: () => UseQueryResult<CaseDbProtocol[]>;
+
+export declare const useTreeAlgorithmCodeOptionsQuery: () => UseOptions<string>;
+
+export declare const useUserAccessCasePoliciesQuery: (select?: (data: CaseDbUserAccessCasePolicy[]) => CaseDbUserAccessCasePolicy[]) => UseQueryResult<CaseDbUserAccessCasePolicy[]>;
+
+export declare const useUserCasePolicyNameFactory: () => UseNameFactory<CaseDbUserAccessCasePolicy | CaseDbUserShareCasePolicy>;
+
+export declare const useUserEffectiveRightsQuery: (userId: string) => Partial<UseQueryResult<UserEffectiveRightsQueryResult>>;
+
+export declare const useUserShareCasePoliciesQuery: (select?: (data: CaseDbUserShareCasePolicy[]) => CaseDbUserShareCasePolicy[]) => UseQueryResult<CaseDbUserShareCasePolicy[]>;
+
+declare interface WidgetData {
+    isUnavailable: boolean;
+}
+
+export declare const WidgetHeaderIconButton: ({ label, ...props }: WidgetHeaderIconButtonProps) => JSX.Element;
+
+export declare interface WidgetHeaderIconButtonProps extends IconButtonProps {
+    readonly label: string;
+}
+
+export declare type WidgetProps = PropsWithChildren<{
+    readonly expandDisabled?: boolean;
+    readonly isLoading?: boolean;
+    readonly primaryMenu?: MenuItemData[] | ReactNode;
+    readonly secondaryMenu?: MenuItemData[] | ReactNode;
+    readonly title: MenuItemData | ReactNode | string;
+    readonly warningMessage?: string;
+    readonly zone: EPI_ZONE;
+}>;
+
+export declare const withEpiDashboardStore: <P extends WithEpiDashboardStoreProps>(WrappedComponent: ComponentType<P>) => ComponentType<P>;
+
+export declare type WithEpiDashboardStoreProps = EpiDashboardStoreLoaderProps;
+
 export { }