@gen-epix/ui 1.14.5 → 1.15.0

package/src/models/epi.ts

@@ -0,0 +1,188 @@
+import type {
+  ColType,
+  Col,
+  RefCol,
+  GeneticDistanceProtocol,
+  TreeAlgorithm,
+  Organization,
+  ConceptSet,
+  Concept,
+  RegionSet,
+  Region,
+  DataCollection,
+  CaseUploadResult,
+} from '../api';
+
+export type CaseTypeRowValue = {
+  raw: string;
+  short: string;
+  long: string;
+  full: string;
+  isMissing?: boolean;
+};
+
+export enum STRATIFICATION_MODE {
+  FIELD = 'FIELD',
+  SELECTION = 'SELECTION',
+}
+
+export type StratificationLegendaItem = {
+  color: string;
+  caseIds: string[];
+  rowValue: CaseTypeRowValue;
+  columnType?: ColType;
+};
+
+export enum STRATIFICATION_SELECTED {
+  SELECTED = 'SELECTED',
+  UNSELECTED = 'UNSELECTED',
+}
+
+export type Stratification = {
+  mode: STRATIFICATION_MODE;
+  caseIdColors: { [key: string]: string };
+  legendaItems?: StratificationLegendaItem[];
+  legendaItemsByColor?: { [key: string]: StratificationLegendaItem };
+  legendaItemsByValue?: { [key: string]: StratificationLegendaItem };
+  col?: Col;
+};
+
+export enum EPI_ZONE {
+  LINE_LIST = 'LINE_LIST',
+  EPI_CURVE = 'EPI_CURVE',
+  MAP = 'MAP',
+  TREE = 'TREE',
+  LEGENDA = 'LEGENDA',
+}
+
+export type Highlighting = {
+  caseIds: string[];
+  origin: EPI_ZONE;
+};
+
+export type TreeFocus = {
+  root: string;
+  leafs: string[];
+};
+
+export enum FILTER_TYPE {
+  DATE = 'DATE',
+  NUMBER = 'NUMBER',
+  MULTI_SELECT = 'MULTI_SELECT',
+  STRING = 'STRING',
+  GEO = 'GEO',
+}
+
+export type EpiDashboardLayoutPanelOrientation = 'vertical' | 'horizontal';
+export type EpiDashboardLayoutSecondAxisPanel = [30 | 70 | 50 | 100, EPI_ZONE];
+export type EpiDashboardLayoutFirstAxisPanel = [30 | 70 | 50 | 100, ...EpiDashboardLayoutSecondAxisPanel[]];
+export type EpiDashboardLayout = [EpiDashboardLayoutPanelOrientation, ...EpiDashboardLayoutFirstAxisPanel[]];
+export type EpiDashboardLayoutConfig = { zones: EPI_ZONE[]; layouts: EpiDashboardLayout[] };
+export type EpiDashboardLayoutUserConfig = {
+  arrangement: number;
+  zones: {
+    [EPI_ZONE.EPI_CURVE]: boolean;
+    [EPI_ZONE.LINE_LIST]: boolean;
+    [EPI_ZONE.MAP]: boolean;
+    [EPI_ZONE.TREE]: boolean;
+  };
+};
+
+export type TreeConfiguration = {
+  computedId: string;
+  refCol: RefCol;
+  col: Col;
+  geneticDistanceProtocol: GeneticDistanceProtocol;
+  treeAlgorithm: TreeAlgorithm;
+};
+
+export type EpiLinkedScrollSubjectValue = {
+  position: number;
+  origin: HTMLElement;
+};
+
+export type EpiData = {
+  organizations: Organization[];
+  organizationsById: { [id: string]: Organization };
+  conceptSets: { [id: string]: ConceptSet };
+  conceptsBySetId: { [id: string]: Concept[] };
+  conceptsIdsBySetId: { [id: string]: string[] };
+  conceptsById: { [id: string]: Concept };
+  regionSets: { [id: string]: RegionSet };
+  regionsByRegionSetId: { [id: string]: Region[] };
+  regionsById: { [id: string]: Region };
+  userDataCollections: DataCollection[];
+  userDataCollectionsById: { [id: string]: DataCollection };
+  treeAlgorithms: TreeAlgorithm[];
+};
+
+export type FindSimilarCasesResult = {
+  key: string;
+  similarCaseIds: string[];
+  originalCaseIds: string[];
+  distance: number;
+  colId: string;
+};
+
+export type EpiCaseHasCaseSet = { [caseId: string]: boolean };
+
+export type EpiUploadMappedColumn = {
+  originalIndex: number;
+  originalLabel: string;
+  col: Col;
+  isCaseIdColumn?: boolean;
+  isCol?: boolean;
+  isSampleIdColumn?: boolean;
+  sampleIdentifierIssuerId?: string;
+};
+
+export type EpiUploadMappedColumnsFormFields = {
+  [key: string]: string;
+};
+
+export type EpiUploadTableRow = {
+  [key: string]: string;
+};
+
+/**
+ * File assignment result for genetic file uploads
+ */
+export interface EpiUploadFileColumnAssignment {
+  file: File;
+  col: Col; // null if no suitable column found
+}
+
+export type CaseUploadResultWithGeneratedId = CaseUploadResult & { generatedId: string };
+
+export type EpiUploadSequenceMappingForCaseId = {
+  sequenceFileNames: {
+    [colId: string]: string;
+  };
+  readsFileNames: {
+    [colId: string]: {
+      fwd: string;
+      rev: string;
+    };
+  };
+};
+
+export type EpiUploadSequenceMapping = {
+  [caseId: string]: EpiUploadSequenceMappingForCaseId;
+};
+
+
+export type EpiUploadCompleteColStats = {
+  sampleIdColumns: Col[];
+  sequenceColumns: Col[];
+  readsColumns: Col[];
+  writableColumns: Col[];
+};
+
+export enum EPI_UPLOAD_STEP {
+  SELECT_FILE = 0,
+  MAP_COLUMNS = 1,
+  VALIDATE = 2,
+  SELECT_SEQUENCE_FILES = 3,
+  MAP_SEQUENCES = 4,
+  CREATE_CASES = 5,
+}

package/src/models/filter.ts

@@ -0,0 +1,39 @@
+import type { TFunction } from 'i18next';
+
+import type {
+  Case,
+  FiltersInner,
+} from '../api';
+import type { BooleanFilter } from '../classes/filters/BooleanFilter';
+import type { DateFilter } from '../classes/filters/DateFilter';
+import type { GeoFilter } from '../classes/filters/GeoFilter';
+import type { MultiSelectFilter } from '../classes/filters/MultiSelectFilter';
+import type { NumberRangeFilter } from '../classes/filters/NumberRangeFilter';
+import type { SelectionFilter } from '../classes/filters/SelectionFilter';
+import type { TextFilter } from '../classes/filters/TextFilter';
+import type { TreeFilter } from '../classes/filters/TreeFilter';
+
+export interface Filter<TFilterValue, TRowValue> {
+  initialFilterValue: TFilterValue;
+  filterValue: TFilterValue;
+  label: string;
+  getPresentationValue: (value?: unknown, t?: TFunction<'translation', undefined>) => string;
+  matchRowValue: (rowValue: TRowValue, row?: Case) => boolean;
+  isInitialFilterValue: (value?: TFilterValue) => boolean;
+  setFilterValue: (value: TFilterValue) => void;
+  toBackendFilter: () => FiltersInner;
+}
+
+export type Filters = Array<DateFilter | GeoFilter | MultiSelectFilter | TextFilter | BooleanFilter | NumberRangeFilter | TreeFilter | SelectionFilter>;
+
+export type FilterValues = { [key: string]: unknown };
+
+export type FilterDimension = {
+  id: string;
+  label: string;
+  description: string;
+  filterIds: string[];
+  preferredFilterId: string;
+  allowMultipleVisibleFilters: boolean;
+  allowOnlyPreferredFilter: boolean;
+};

package/src/models/form.ts

@@ -0,0 +1,74 @@
+import type {
+  FieldValues,
+  Path,
+} from 'react-hook-form';
+
+import type { RichTextEditorProps } from '../components/form/fields/RichTextEditor';
+import type { TransferListProps } from '../components/form/fields/TransferList';
+import type { AutocompleteProps } from '../components/form/fields/Autocomplete';
+import type { TextFieldProps } from '../components/form/fields/TextField';
+import type { SelectProps } from '../components/form/fields/Select';
+import type { DatePickerProps } from '../components/form/fields/DatePicker';
+import type { UploadButtonProps } from '../components/form/fields/UploadButton/UploadButton';
+import type { RadioGroupProps } from '../components/form/fields/RadioGroup';
+import type { NumberFieldProps } from '../components/form/fields/NumberField';
+
+
+export interface OptionBase<TValue> {
+  value?: TValue;
+  label?: string;
+  disabled?: boolean;
+}
+
+export interface AutoCompleteOption<TValue = void> extends OptionBase<TValue extends void ? (string | number) : TValue> {
+  groupBySortOrderValue?: number;
+  groupByValue?: string;
+}
+export type RadioButtonOption<TValue = void> = OptionBase<TValue extends void ? (boolean | string | number) : TValue>;
+export type SelectOption<TValue = void> = OptionBase<TValue extends void ? (boolean | string | number) : TValue>;
+export type ToggleButtonOption<TValue = void> = OptionBase<TValue extends void ? (boolean | string | number) : TValue>;
+export type CheckboxOption = OptionBase<string | number>;
+export type TransferListOption = OptionBase<string>;
+
+export enum FORM_FIELD_DEFINITION_TYPE {
+  TRANSFER_LIST = 'TRANSFER_LIST',
+  AUTOCOMPLETE = 'AUTOCOMPLETE',
+  SELECT = 'SELECT',
+  FILE = 'FILE',
+  TEXTFIELD = 'TEXTFIELD',
+  NUMBER = 'NUMBER',
+  RICH_TEXT = 'RICH_TEXT',
+  BOOLEAN = 'BOOLEAN',
+  HIDDEN = 'HIDDEN',
+  DATE = 'DATE',
+  RADIO_GROUP = 'RADIO_GROUP',
+}
+
+export type FormFieldDefinitionAutocomplete<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE; multiple?: false } & AutocompleteProps<TFormFields, Path<TFormFields>, false>;
+export type FormFieldDefinitionAutocompleteMultiple<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE; multiple?: true } & AutocompleteProps<TFormFields, Path<TFormFields>, true>;
+export type FormFieldDefinitionTextField<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.TEXTFIELD } & TextFieldProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionNumber<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.NUMBER } & NumberFieldProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionBoolean<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.BOOLEAN } & Omit<SelectProps<TFormFields, Path<TFormFields>, false>, 'options'>;
+export type FormFieldDefinitionTransferList<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.TRANSFER_LIST } & TransferListProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionHidden<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.HIDDEN } & TextFieldProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionRichText<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.RICH_TEXT } & RichTextEditorProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionDate<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.DATE } & DatePickerProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionFile<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.FILE } & UploadButtonProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionRadioGroup<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.RADIO_GROUP } & RadioGroupProps<TFormFields, Path<TFormFields>>;
+export type FormFieldDefinitionSelect<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.SELECT; multiple?: false } & SelectProps<TFormFields, Path<TFormFields>, false>;
+export type FormFieldDefinitionSelectMultiple<TFormFields extends FieldValues> = { definition: FORM_FIELD_DEFINITION_TYPE.SELECT; multiple?: true } & SelectProps<TFormFields, Path<TFormFields>, true>;
+
+export type FormFieldDefinition<TFormFields extends FieldValues> =
+  FormFieldDefinitionAutocomplete<TFormFields> |
+  FormFieldDefinitionAutocompleteMultiple<TFormFields> |
+  FormFieldDefinitionTextField<TFormFields> |
+  FormFieldDefinitionNumber<TFormFields> |
+  FormFieldDefinitionBoolean<TFormFields> |
+  FormFieldDefinitionTransferList<TFormFields> |
+  FormFieldDefinitionHidden<TFormFields> |
+  FormFieldDefinitionRichText<TFormFields> |
+  FormFieldDefinitionDate<TFormFields> |
+  FormFieldDefinitionFile<TFormFields> |
+  FormFieldDefinitionRadioGroup<TFormFields> |
+  FormFieldDefinitionSelect<TFormFields> |
+  FormFieldDefinitionSelectMultiple<TFormFields>;

package/src/models/generic.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type
+export type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never;
+
+export type UnwrapArray<T> = T extends Array<infer U> ? U : T;

package/src/models/nestedMenu.ts

@@ -0,0 +1,21 @@
+import type { SxProps } from '@mui/material';
+import type {
+  ReactElement,
+  ReactNode,
+} from 'react';
+
+export interface MenuItemData {
+  uid?: string;
+  label?: string;
+  tooltip?: string | ReactElement;
+  leftIcon?: ReactNode;
+  rightIcon?: ReactNode;
+  callback?: () => void;
+  items?: MenuItemData[];
+  disabled?: boolean;
+  divider?: boolean;
+  autoCloseDisabled?: boolean;
+  sx?: SxProps;
+  active?: boolean;
+  checked?: 'true' | 'false' | 'mixed';
+}

package/src/models/notification.ts

@@ -0,0 +1,12 @@
+import type { AlertColor } from '@mui/material';
+import type { ReactElement } from 'react';
+
+export interface Notification {
+  isLoading?: boolean;
+  message: string | ReactElement;
+  severity: AlertColor;
+  key: string;
+  autoHideAfterMs?: number;
+  visible?: boolean;
+  timestamp: number;
+}

package/src/models/outage.ts

@@ -0,0 +1,7 @@
+import type { Outage } from '../api';
+
+export type CategorizedOutages = {
+  visibleOutages: Outage[];
+  activeOutages: Outage[];
+  soonActiveOutages: Outage[];
+};

package/src/models/query.ts

@@ -0,0 +1,75 @@
+export enum QUERY_KEY {
+  ASSEMBLY_PROTOCOLS = 'ASSEMBLY_PROTOCOLS',
+  ALLELE_PROFILES = 'ALLELE_PROFILES',
+  CASE_DATA_COLLECTION_LINKS = 'CASE_DATA_COLLECTION_LINKS',
+  CASE_IDS_BY_QUERY = 'CASE_IDS_BY_QUERY',
+  CASE_RIGHTS = 'CASE_RIGHTS',
+  CASE_SET_CATEGORIES = 'CASE_SET_CATEGORIES',
+  CASE_SET_DATA_COLLECTION_LINKS = 'CASE_SET_DATA_COLLECTION_LINKS',
+  CASE_SET_MEMBERS = 'CASE_SET_MEMBERS',
+  CASE_SET_RIGHTS = 'CASE_SET_RIGHTS',
+  CASE_SET_STATS = 'CASE_SET_STATS',
+  CASE_SET_STATUSES = 'CASE_SET_STATUSES',
+  CASE_SETS = 'CASE_SETS',
+  COL_SET_MEMBERS = 'COL_SET_MEMBERS',
+  COL_SETS = 'COL_SETS',
+  COLS = 'COLS',
+  DIMS = 'DIMS',
+  CASE_TYPE_SET_CATEGORIES = 'CASE_TYPE_SET_CATEGORIES',
+  CASE_TYPE_SET_MEMBERS = 'CASE_TYPE_SET_MEMBERS',
+  CASE_TYPE_SETS = 'CASE_TYPE_SETS',
+  CASE_TYPE_STATS = 'CASE_TYPE_STATS',
+  CASE_TYPES = 'CASE_TYPES',
+  CASES = 'CASES',
+  CASES_LAZY = 'CASES_LAZY',
+  REF_COLS = 'REF_COLS',
+  COMPLETE_CASE_TYPES = 'COMPLETE_CASE_TYPES',
+  CONCEPT_SETS = 'CONCEPT_SETS',
+  CONCEPTS = 'CONCEPTS',
+  CONCEPT_RELATIONS = 'CONCEPT_RELATIONS',
+  CONTACTS = 'CONTACTS',
+  DATA_COLLECTION_SET_MEMBERS = 'DATA_COLLECTION_SET_MEMBERS',
+  DATA_COLLECTION_SETS = 'DATA_COLLECTION_SETS',
+  DATA_COLLECTIONS = 'DATA_COLLECTIONS',
+  REF_DIMS = 'REF_DIMS',
+  DISEASES = 'DISEASES',
+  ETIOLOGICAL_AGENTS = 'ETIOLOGICAL_AGENTS',
+  ETIOLOGIES = 'ETIOLOGIES',
+  GENETIC_DISTANCE_PROTOCOLS = 'GENETIC_DISTANCE_PROTOCOLS',
+  GENETIC_SEQUENCES = 'GENETIC_SEQUENCES',
+  IDENTITY_PROVIDERS = 'IDENTITY_PROVIDERS',
+  INVITE_USER_CONSTRAINTS = 'INVITE_USER_CONSTRAINTS',
+  LICENSES = 'LICENSES',
+  SEQUENCING_PROTOCOLS = 'SEQUENCING_PROTOCOLS',
+  ORGANIZATION_ACCESS_CASE_POLICIES = 'ORGANIZATION_ACCESS_CASE_POLICIES',
+  ORGANIZATION_ADMIN_NAME_EMAILS = 'ORGANIZATION_ADMIN_NAME_EMAILS',
+  ORGANIZATION_ADMIN_POLICIES = 'ORGANIZATION_ADMIN_POLICIES',
+  ORGANIZATION_SHARE_CASE_POLICIES = 'ORGANIZATION_SHARE_CASE_POLICIES',
+  ORGANIZATIONS = 'ORGANIZATIONS',
+  OUTAGES = 'OUTAGES',
+  PHYLOGENETIC_TREE = 'PHYLOGENETIC_TREE',
+  REGION_SET_SHAPES = 'REGION_SET_SHAPES',
+  REGION_SETS = 'REGION_SETS',
+  REGION_SETS_LAZY = 'REGION_SETS_LAZY',
+  REGION_RELATIONS = 'REGION_RELATIONS',
+  REGIONS = 'REGIONS',
+  REGIONS_LAZY = 'REGIONS_LAZY',
+  SIMILAR_CASES = 'SIMILAR_CASES',
+  SITES = 'SITES',
+  SUBJECTS = 'SUBJECT_IDENTIFIERS',
+  TREE_ALGORITHM_CLASSES = 'TREE_ALGORITHM_CLASSES',
+  TREE_ALGORITHMS = 'TREE_ALGORITHMS',
+  USER_ACCESS_CASE_POLICIES = 'USER_ACCESS_CASE_POLICIES',
+  USER_ME = 'USER_ME',
+  USER_PERMISSIONS = 'USER_PERMISSIONS',
+  USER_INVITATIONS = 'USER_INVITATIONS',
+  USER_SHARE_CASE_POLICIES = 'USER_SHARE_CASE_POLICIES',
+  USERS = 'USERS',
+  VALIDATE_CASES = 'VALIDATE_CASES',
+  IDENTIFIER_ISSUERS = 'IDENTIFIER_ISSUERS',
+  IDENTIFIER_ISSUERS_OWN_ORGANIZATION = 'IDENTIFIER_ISSUERS_OWN_ORGANIZATION',
+  IDENTIFIER_ISSUER_LINKS = 'IDENTIFIER_ISSUER_LINKS',
+  REF_COLS_VALIDATION_RULES = 'REF_COLS_VALIDATION_RULES',
+  XXX_CASE_ID_HAS_CASE_SET = 'XXX_CASE_ID_HAS_CASE_SET',
+  FEATURE_FLAGS = 'FEATURE_FLAGS',
+}

package/src/models/reactRouter.ts

@@ -0,0 +1,36 @@
+import type { ReactElement } from 'react';
+import type {
+  IndexRouteObject,
+  NonIndexRouteObject,
+} from 'react-router';
+
+import type { ApiPermission } from '../api';
+
+export type UseLoaderData<T> = {
+  data: T;
+};
+
+export type MyHandle = {
+  root?: boolean;
+  title: string;
+  subTitle?: string;
+  icon?: ReactElement;
+  hidden?: boolean;
+  disabled?: boolean;
+  requiredPermissions: ApiPermission[];
+  requiresUserProfile: boolean;
+  requirePermissionForChildRoute?: boolean;
+  category?: string;
+};
+
+export type MyIndexRouteObject = Omit<IndexRouteObject, 'handle'> & {
+  handle?: MyHandle;
+};
+
+export type MyNonIndexRouteObject = Omit<
+  NonIndexRouteObject,
+  'handle' | 'children'
+> & {
+  handle?: MyHandle;
+  children?: Array<MyNonIndexRouteObject | MyIndexRouteObject>;
+};

package/src/models/table.ts

@@ -0,0 +1,191 @@
+import type {
+  SxProps,
+  Theme,
+} from '@mui/material';
+import type { ReactElement } from 'react';
+import type { TFunction } from 'i18next';
+
+import type {
+  CompleteCaseType,
+  Col,
+} from '../api';
+import type { DATE_FORMAT } from '../data/date';
+
+import type { CaseTypeRowValue } from './epi';
+import type { OptionBase } from './form';
+
+export enum FIXED_COLUMN_ID {
+  ROW_SELECT = 'ROW_SELECT',
+  READABLE_INDEX = 'READABLE_INDEX',
+  ACTIONS = 'ACTIONS',
+}
+
+export interface TableColumnParams<TRowData> {
+  columnIndex: number;
+  column: TableColumn<TRowData>;
+}
+
+export interface TableRowParams<TRowData> {
+  id: string;
+  row: TRowData;
+  rowIndex: number;
+}
+
+export type TableRowAndColumnParams<TRowData> = TableRowParams<TRowData> & TableColumnParams<TRowData>;
+
+interface TableColumnBase<TRowData, TValue> {
+  cellTitleGetter?: (params: TableRowParams<TRowData>) => string;
+  filterLabel?: string;
+  frozen?: boolean;
+  headerName?: string;
+  headerTooltipContent?: string;
+  hideInFilter?: boolean;
+  id?: string;
+  isInitiallyVisible: boolean;
+  renderCell?: (params: TableRowAndColumnParams<TRowData>) => ReactElement;
+  renderHeaderContent?: (params: TableColumnParams<TRowData>) => ReactElement;
+  renderHeader?: (params: TableColumnParams<TRowData>) => ReactElement;
+  resizable?: boolean;
+  sx?: SxProps<Theme>;
+  textAlign?: 'left' | 'right';
+  isStatic?: boolean;
+  valueGetter?: (params: TableRowParams<TRowData>) => TValue;
+  displayValueGetter?: (params: TableRowParams<TRowData>) => string;
+  widthFlex?: number;
+  widthPx?: number;
+  widthPxFn?: (dataLength: number) => number;
+  disableEllipsis?: boolean;
+}
+
+export interface TableColumnText<TRowData> extends TableColumnBase<TRowData, string> {
+  type: 'text';
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnText<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface TableColumnReadableIndex<TRowData> extends TableColumnBase<TRowData, never> {
+  type: 'readableIndex';
+  id: FIXED_COLUMN_ID.READABLE_INDEX;
+  comparatorFactory?: never;
+  isStatic: true;
+  frozen: true;
+  resizable: false;
+  disableEllipsis: true;
+  getAriaLabel: (params: TableRowParams<TRowData>) => string;
+}
+
+export interface TableColumnSelectable<TRowData> extends TableColumnBase<TRowData, never> {
+  type: 'selectable';
+  id: FIXED_COLUMN_ID.ROW_SELECT;
+  comparatorFactory?: never;
+  isStatic: true;
+  frozen: true;
+  resizable: false;
+  disableEllipsis: true;
+  isDisabled?: (params: TableRowParams<TRowData>) => boolean;
+}
+
+export interface TableColumnBoolean<TRowData> extends TableColumnBase<TRowData, boolean> {
+  type: 'boolean';
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnBoolean<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface TableColumnNumber<TRowData> extends TableColumnBase<TRowData, number> {
+  type: 'number';
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnNumber<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface TableColumnDate<TRowData> extends TableColumnBase<TRowData, string> {
+  type: 'date';
+  dateFormat: typeof DATE_FORMAT[keyof typeof DATE_FORMAT];
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnDate<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface TableColumnOptions<TRowData> extends TableColumnBase<TRowData, string | string[]> {
+  type: 'options';
+  options: OptionBase<string>[];
+  maxNumOptionsExpanded?: number;
+  shouldFilterOptions?: boolean;
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnOptions<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface TableColumnActions<TRowData> extends TableColumnBase<TRowData, string> {
+  id: FIXED_COLUMN_ID.ACTIONS;
+  type: 'actions';
+  getActions: (params: TableRowParams<TRowData>) => ReactElement[];
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnActions<TRowData>>) => (a: TRowData, b: TRowData) => number;
+  isInitiallyVisible: true;
+  resizable: false;
+  isStatic: true;
+}
+
+export interface TableColumnCaseType<TRowData> extends TableColumnBase<TRowData, CaseTypeRowValue> {
+  type: 'caseType';
+  completeCaseType: CompleteCaseType;
+  col: Col;
+  comparatorFactory?: (params: GetTableCellRowComparatorProps<TableColumnCaseType<TRowData>>) => (a: TRowData, b: TRowData) => number;
+}
+
+export interface GetTableCellValueProps<TRowData, TColumn> {
+  readonly row: TRowData;
+  readonly column: TColumn;
+  readonly rowIndex: number;
+  readonly t?: TFunction<'translation', undefined>;
+}
+
+export interface GetTableCellRowComparatorProps<TColumn> {
+  readonly column: TColumn;
+  readonly direction: TableSortDirection;
+}
+
+export type TableCellRowComparatorArgument<TRowData> = {
+  row: TRowData;
+  rowIndex: number;
+};
+
+export type TableColumn<TRowData> =
+  TableColumnText<TRowData> |
+  TableColumnBoolean<TRowData> |
+  TableColumnNumber<TRowData> |
+  TableColumnDate<TRowData> |
+  TableColumnOptions<TRowData> |
+  TableColumnActions<TRowData> |
+  TableColumnReadableIndex<TRowData> |
+  TableColumnSelectable<TRowData> |
+  TableColumnCaseType<TRowData>;
+
+export type TableSortDirection = 'asc' | 'desc';
+
+
+export type TableColumnSettings = {
+  id: string;
+  widthPx: number;
+  widthFlex: number;
+  offsetX?: number;
+  calculatedWidth?: number;
+  hasResized?: boolean;
+  isVisible: boolean;
+};
+
+export type TableSettings = {
+  availableColumnIds: string[];
+  columns: TableColumnSettings[];
+};
+
+export type TableColumnDimension = {
+  id: string;
+  label: string;
+  columnIds: string[];
+};
+
+export type HasCellDataFn<TRowData> = (row: TRowData, column: TableColumn<TRowData>, rowIndex: number) => boolean;
+
+export type TableDragEvent = {
+  deltaX: number;
+  deltaY: number;
+  clientX: number;
+  clientY: number;
+  elementOffsetX: number;
+  elementWidth: number;
+  type: 'start' | 'move' | 'end';
+  target: HTMLDivElement;
+};

package/src/models/testId.ts

@@ -0,0 +1 @@
+export type PropsWithTestIdAttributes<P> = P & { testIdAttributes: Record<string, string> };

package/src/models/tree.ts

@@ -0,0 +1,32 @@
+import type Decimal from 'decimal.js';
+
+export type TreeNode = {
+  children?: TreeNode[];
+  name?: string;
+  subTreeNames?: string[];
+  subTreeLeaveNames?: string[];
+  branchLength?: Decimal;
+  maxBranchLength?: Decimal;
+  size?: number;
+  address?: string;
+};
+
+export type TreePathProperties = {
+  subTreeLeaveNames: string[];
+  treeNode?: TreeNode;
+};
+
+type TreeAssemblyPathPropertiesMap = Map<Path2D, TreePathProperties>;
+
+export type TreeAssembly = {
+  verticalAncestorTreeLines: Array<{ nodeNames: string[]; shape: Path2D }>;
+  horizontalAncestorTreeLines: Array<{ nodeNames: string[]; shape: Path2D }>;
+  ancestorNodes: Array<{ nodeNames: string[]; shape: Path2D }>;
+  leafNodes: Array<{ nodeName: string; shape: Path2D }>;
+  leafTreeLines: Array<{ nodeName: string; shape: Path2D }>;
+  supportLines: Array<{ nodeName: string; fromX: number; toX: number; y: number }>;
+  distanceTexts: Array<{ nodeNames: string[]; x: number; y: number; text: string }>;
+  nodePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+  horizontalLinePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+  verticalLinePathPropertiesMap: TreeAssemblyPathPropertiesMap;
+};