@mathstack/ui 0.0.1-beta.0

package/lib/combobox/editable-textbox/editable-textbox.component.d.ts

@@ -0,0 +1,39 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { ComboboxAction } from '../combobox.service';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import { TextboxComponent } from '../textbox/textbox.component';
+import * as i0 from "@angular/core";
+export declare class EditableTextboxComponent extends TextboxComponent implements OnInit, AfterViewInit {
+    inputElRef: ElementRef<HTMLInputElement>;
+    autoSelect: boolean;
+    autoSelectTrigger: 'any' | 'character';
+    displaySelected: boolean;
+    initialValue: string;
+    inputType: 'text' | 'search';
+    ngFormControl: FormControl<string>;
+    placeholder: string;
+    valueChanges: EventEmitter<string>;
+    moveFocusToTextboxKeys: string[];
+    value: BehaviorSubject<string>;
+    value$: import("rxjs").Observable<string>;
+    openKeys: string[];
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setLabel(): void;
+    onSelectionChange(selectedOptions: ListboxOptionComponent[]): void;
+    onInputChange(value: string): void;
+    setAndEmitValue(value: string): void;
+    setValue(value: string): void;
+    emitValue(value: string): void;
+    handleClick(): void;
+    protected setAutoSelectWhenInputIsEmpty(): void;
+    onEscape(): void;
+    getActionFromKeydownEvent(event: KeyboardEvent): ComboboxAction;
+    getActionFromKeydownEventWhenOpen(event: KeyboardEvent): ComboboxAction;
+    handleKeyboardAction(action: string, event: KeyboardEvent): void;
+    isPrintableCharacter(str: string): RegExpMatchArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTextboxComponent, "hsi-ui-editable-textbox", never, { "autoSelect": { "alias": "autoSelect"; "required": false; }; "autoSelectTrigger": { "alias": "autoSelectTrigger"; "required": false; }; "displaySelected": { "alias": "displaySelected"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "ngFormControl": { "alias": "ngFormControl"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "valueChanges": "valueChanges"; }, never, ["[boxIcon]"], true, never>;
+}

package/lib/combobox/index.d.ts

@@ -0,0 +1,11 @@
+export * from './combobox-label/combobox-label.component';
+export * from './combobox.component';
+export * from './combobox.module';
+export * from './combobox.service';
+export * from './editable-textbox/editable-textbox.component';
+export * from './listbox-group/listbox-group.component';
+export * from './listbox-label/listbox-label.component';
+export * from './listbox-option/listbox-option.component';
+export * from './listbox/listbox.component';
+export * from './select-all-listbox-option/select-all-listbox-option.component';
+export * from './textbox/textbox.component';

package/lib/combobox/listbox/active-index.service.d.ts

@@ -0,0 +1,32 @@
+import { DestroyRef, ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ComboboxService, OptionAction } from '../combobox.service';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import { ListboxFilteringService } from './listbox-filtering.service';
+import { ListboxScrollService } from './listbox-scroll.service';
+import * as i0 from "@angular/core";
+export declare class ActiveIndexService {
+    private service;
+    private filtering;
+    private scrolling;
+    private activeIndex;
+    activeIndex$: Observable<number>;
+    scrollContentRef: ElementRef<HTMLDivElement>;
+    constructor(service: ComboboxService, filtering: ListboxFilteringService, scrolling: ListboxScrollService);
+    init(allOptions$: Observable<ListboxOptionComponent[]>, destroyRef: DestroyRef): void;
+    setScrollContentRef(scrollContentRef: ElementRef): void;
+    initActiveId(): void;
+    listenToActions(allOptions$: Observable<ListboxOptionComponent[]>, destroyRef: DestroyRef): void;
+    private setNextActiveIndex;
+    private setPrevActiveIndex;
+    setActiveIndex(index: number | null, actionIfDisabled: OptionAction.next | OptionAction.previous | null, options: ListboxOptionComponent[], scrollToIndex?: boolean): void;
+    handleActiveIndexWhenCannotBeSet(): void;
+    private handleScrollingForNewIndex;
+    private getIndexForAction;
+    actionIsTypingChar(action: OptionAction | string): boolean;
+    updateActiveIndexFromKeyChar(char: string, options: ListboxOptionComponent[]): void;
+    private setActiveDescendant;
+    setActiveIndexToFirstSelectedOrDefault(options: ListboxOptionComponent[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveIndexService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActiveIndexService>;
+}

package/lib/combobox/listbox/listbox-filtering.service.d.ts

@@ -0,0 +1,12 @@
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import * as i0 from "@angular/core";
+export declare class ListboxFilteringService {
+    searchTimeout: ReturnType<typeof setTimeout>;
+    searchString: string;
+    updateSearchString(char: string): void;
+    resetSearch(): void;
+    getIndexByLetter(options: ListboxOptionComponent[], searchString: string, startIndex: number): number;
+    filterOptionsBySearchString(options: ListboxOptionComponent[], searchString: string, exclude?: ListboxOptionComponent[]): ListboxOptionComponent[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxFilteringService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListboxFilteringService>;
+}

package/lib/combobox/listbox/listbox-scroll.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class ListboxScrollService {
+    private document;
+    constructor(document: Document);
+    isElementInView(element: HTMLElement): boolean;
+    isScrollable(element: HTMLElement): boolean;
+    maintainElementVisibility(activeElement: HTMLElement, scrollParent: HTMLElement): void;
+    scrollToTop(scrollParent: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListboxScrollService>;
+}

package/lib/combobox/listbox/listbox.component.d.ts

@@ -0,0 +1,58 @@
+import { AfterContentInit, AfterViewInit, DestroyRef, ElementRef, EventEmitter, OnChanges, QueryList, SimpleChanges } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { ComboboxService, OptionAction } from '../combobox.service';
+import { ListboxGroupComponent } from '../listbox-group/listbox-group.component';
+import { ListboxLabelComponent } from '../listbox-label/listbox-label.component';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import { SelectAllListboxOptionComponent } from '../select-all-listbox-option/select-all-listbox-option.component';
+import { ActiveIndexService } from './active-index.service';
+import { ListboxFilteringService } from './listbox-filtering.service';
+import { ListboxScrollService } from './listbox-scroll.service';
+import * as i0 from "@angular/core";
+export type SelectedCountLabel = {
+    singular: string;
+    plural: string;
+};
+export declare class ListboxComponent implements OnChanges, AfterContentInit, AfterViewInit {
+    service: ComboboxService;
+    activeIndex: ActiveIndexService;
+    protected filtering: ListboxFilteringService;
+    protected scrolling: ListboxScrollService;
+    protected destroyRef: DestroyRef;
+    ngFormControl: FormControl<any | any[]>;
+    findsOptionOnTyping: boolean;
+    isMultiSelect: boolean;
+    maxHeight: number;
+    valueChanges: EventEmitter<any>;
+    scrollableContentRef: ElementRef<HTMLDivElement>;
+    label: ListboxLabelComponent;
+    options: QueryList<ListboxOptionComponent>;
+    groups: QueryList<ListboxGroupComponent>;
+    constructor(service: ComboboxService, activeIndex: ActiveIndexService, filtering: ListboxFilteringService, scrolling: ListboxScrollService, destroyRef: DestroyRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    setOnOptionChanges(): void;
+    setSelectedEmitting(): void;
+    emitValue(selections: any[]): void;
+    setOnBlurEvent(): void;
+    shouldAutoSelectOptionOnBlur(activeIndex: number, options: ListboxOptionComponent[]): boolean;
+    setOptionAction(): void;
+    actionIsTypingChar(action: OptionAction | string): boolean;
+    setResetOnClose(): void;
+    resetScroll(): void;
+    getListboxLabelAsBoxPlaceholder(): string;
+    selectOptionFromIndex(index: number, options: ListboxOptionComponent[]): void;
+    handleOptionClick(event: MouseEvent, optionIndex: number, groupIndex?: number): void;
+    handleOptionSelect(optionIndex: number, options: ListboxOptionComponent[], groupIndex?: number): void;
+    toggleOptionSelected(option: ListboxOptionComponent, options: ListboxOptionComponent[]): void;
+    updateSelectedOptionsToEmit(options: ListboxOptionComponent[]): void;
+    selectSingleSelectOption(option: ListboxOptionComponent, options: ListboxOptionComponent[]): void;
+    isSelectAllListboxOption(option: ListboxOptionComponent): option is SelectAllListboxOptionComponent;
+    getOptionIndexFromGroups(groupIndex: number, optionIndex: number): number;
+    getSelectedOptions(options: ListboxOptionComponent[]): ListboxOptionComponent[];
+    updateActiveIndexOnExternalChanges(): void;
+    handleOptionMousedown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxComponent, "hsi-ui-listbox", never, { "ngFormControl": { "alias": "ngFormControl"; "required": false; }; "findsOptionOnTyping": { "alias": "findsOptionOnTyping"; "required": false; }; "isMultiSelect": { "alias": "isMultiSelect"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "valueChanges": "valueChanges"; }, ["label", "options", "groups"], never, true, never>;
+}

package/lib/combobox/listbox-group/listbox-group.component.d.ts

@@ -0,0 +1,16 @@
+import { AfterContentInit, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ComboboxService } from '../combobox.service';
+import { ListboxLabelComponent } from '../listbox-label/listbox-label.component';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import * as i0 from "@angular/core";
+export declare class ListboxGroupComponent implements AfterContentInit {
+    service: ComboboxService;
+    label: ListboxLabelComponent;
+    options: QueryList<ListboxOptionComponent>;
+    options$: Observable<ListboxOptionComponent[]>;
+    constructor(service: ComboboxService);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxGroupComponent, "hsi-ui-listbox-group", never, {}, {}, ["label", "options"], ["*"], true, never>;
+}

package/lib/combobox/listbox-label/listbox-label.component.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { ComboboxService } from '../combobox.service';
+import * as i0 from "@angular/core";
+export declare class ListboxLabelComponent {
+    private service;
+    labelContent: TemplateRef<unknown>;
+    label: ElementRef<HTMLParagraphElement>;
+    id: string;
+    constructor(service: ComboboxService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxLabelComponent, "hsi-ui-listbox-label", never, {}, {}, never, ["*"], true, never>;
+}

package/lib/combobox/listbox-option/listbox-option.component.d.ts

@@ -0,0 +1,52 @@
+import { ElementRef, OnChanges, SimpleChanges, TemplateRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ComboboxService } from '../combobox.service';
+import * as i0 from "@angular/core";
+export interface ListboxOptionPropertyChange {
+    property: 'selected' | 'disabled';
+    value: boolean;
+    comboboxId: string;
+    id: number;
+    optionValue: string | number | boolean;
+}
+export declare class ListboxOptionComponent implements OnChanges {
+    protected service: ComboboxService;
+    label: ElementRef<HTMLDivElement>;
+    template: TemplateRef<unknown>;
+    boxDisplayLabel: string;
+    value: any;
+    /** Whether the option is selected.
+     * If this property is changed during this component's lifecycle, no new value will be emitted from the listbox.
+     * Box label and select all button will respond to changes.
+     * @default false
+     */
+    selected: boolean;
+    /** Whether the option is selected.
+     * If this property is changed during this component's lifecycle, no new value will be emitted from the listbox.
+     * Box label and select all button will respond to changes.
+     * @default false
+     */
+    disabled: boolean;
+    ariaLabel: string;
+    id: number;
+    protected _selected: BehaviorSubject<boolean>;
+    selected$: import("rxjs").Observable<boolean>;
+    private _disabled;
+    disabled$: import("rxjs").Observable<boolean>;
+    private externalPropertyChanges;
+    externalPropertyChanges$: import("rxjs").Observable<ListboxOptionPropertyChange>;
+    constructor(service: ComboboxService);
+    get valueToEmit(): any | string;
+    ngOnChanges(changes: SimpleChanges): void;
+    isFirstChangeAndValueIsFalse(change: SimpleChanges, property: 'selected' | 'disabled'): boolean;
+    getPropertyChange(property: 'selected' | 'disabled'): ListboxOptionPropertyChange;
+    protected updateSelected(selected: boolean): void;
+    private updateDisabled;
+    select(): void;
+    deselect(): void;
+    toggleSelected(): void;
+    isSelected(): boolean;
+    isDisabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxOptionComponent, "hsi-ui-listbox-option", never, { "boxDisplayLabel": { "alias": "boxDisplayLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*", "[selectedIcon]", "[unselectedIcon]"], true, never>;
+}

package/lib/combobox/select-all-listbox-option/select-all-listbox-option.component.d.ts

@@ -0,0 +1,24 @@
+import { DestroyRef, OnChanges } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ComboboxService } from '../combobox.service';
+import { ListboxGroupComponent } from '../listbox-group/listbox-group.component';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import { ListboxComponent } from '../listbox/listbox.component';
+import * as i0 from "@angular/core";
+export declare class SelectAllListboxOptionComponent extends ListboxOptionComponent implements OnChanges {
+    private listboxComponent;
+    private destroyRef;
+    boxDisplayLabel: string;
+    controlledOptions$: Observable<ListboxOptionComponent[]>;
+    controlledOptions: ListboxOptionComponent[];
+    constructor(service: ComboboxService, listboxComponent: ListboxComponent, destroyRef: DestroyRef);
+    ngOnChanges(): void;
+    protected updateSelected(selected: boolean): void;
+    setControlledOptions(): void;
+    getControlledOptionsFromGroups(groups: ListboxGroupComponent[]): ListboxOptionComponent[];
+    listenForOptionSelections(): void;
+    updateSelectAllSelected(controlledOptions: ListboxOptionComponent[]): void;
+    toggleSelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectAllListboxOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectAllListboxOptionComponent, "hsi-ui-select-all-listbox-option", never, { "boxDisplayLabel": { "alias": "boxDisplayLabel"; "required": false; }; }, {}, never, ["*", "[selectedIcon]", "[unselectedIcon]"], true, never>;
+}

package/lib/combobox/textbox/textbox.component.d.ts

@@ -0,0 +1,41 @@
+import { AfterViewInit, DestroyRef, ElementRef, NgZone, OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ComboboxAction, ComboboxService } from '../combobox.service';
+import { ListboxOptionComponent } from '../listbox-option/listbox-option.component';
+import { SelectedCountLabel } from '../listbox/listbox.component';
+import * as i0 from "@angular/core";
+export declare class TextboxComponent implements OnInit, AfterViewInit {
+    ariaLabel: string;
+    selectedCountLabel?: SelectedCountLabel;
+    customLabel: (selectedOptions: ListboxOptionComponent[]) => string;
+    dynamicLabel: boolean;
+    findsOptionOnTyping: boolean;
+    box: ElementRef<HTMLDivElement>;
+    boxIcon: ElementRef<HTMLDivElement>;
+    openKeys: string[];
+    label: BehaviorSubject<string>;
+    label$: import("rxjs").Observable<string>;
+    protected destroyRef: DestroyRef;
+    service: ComboboxService;
+    private platform;
+    protected zone: NgZone;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setFocusListener(): void;
+    focusBox(): void;
+    handleBlur(event: FocusEvent): void;
+    isHtmlElement(target: EventTarget): target is HTMLElement;
+    isMobile(): boolean;
+    handleClick(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    onEscape(): void;
+    getActionFromKeydownEvent(event: KeyboardEvent): ComboboxAction;
+    isTypingCharacter(event: KeyboardEvent): boolean;
+    getActionFromKeyEventWhenOpen(event: KeyboardEvent): ComboboxAction;
+    handleKeyboardAction(action: ComboboxAction, event: KeyboardEvent): void;
+    setLabel(): void;
+    getComputedLabel(touched: boolean, options: ListboxOptionComponent[]): string;
+    getDefaultLabel(selectedOptions: ListboxOptionComponent[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextboxComponent, "hsi-ui-textbox", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "selectedCountLabel": { "alias": "selectedCountLabel"; "required": false; }; "customLabel": { "alias": "customLabel"; "required": false; }; "dynamicLabel": { "alias": "dynamicLabel"; "required": false; }; "findsOptionOnTyping": { "alias": "findsOptionOnTyping"; "required": false; }; }, {}, never, ["[boxIcon]", "[boxLabel]"], true, never>;
+}

package/lib/directory/directory.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface HsiUiDirectoryItem {
+    name: string;
+    value?: string;
+    children?: HsiUiDirectoryItem[];
+}
+export interface HsiUiDirectorySelection {
+    activePath: string;
+    selectedItem: string;
+}
+export declare class HsiUiDirectoryComponent implements OnChanges {
+    items: HsiUiDirectoryItem[];
+    level: number;
+    path: string;
+    terminalItemsAreSelectable: boolean;
+    selectionElementRole: string;
+    /**
+     * Sets the activePath and selectedItem.
+     */
+    selection: HsiUiDirectorySelection;
+    /**
+     * Emits the activePath and selectedItem when a leaf item is selected.
+     *
+     * Constructed from the `value` of each item if provided, otherwise uses `name`.
+     */
+    selectionChanges: EventEmitter<HsiUiDirectorySelection>;
+    /**
+     * @internal
+     *
+     * Internal, will have no effect if provided at root level.
+     */
+    stateChanges: EventEmitter<HsiUiDirectorySelection>;
+    state: BehaviorSubject<HsiUiDirectorySelection>;
+    state$: import("rxjs").Observable<HsiUiDirectorySelection>;
+    open: {};
+    ngOnChanges(changes: SimpleChanges): void;
+    toggleOpen(key: string): void;
+    selectItem(item: HsiUiDirectoryItem): void;
+    setState(state: HsiUiDirectorySelection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HsiUiDirectoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HsiUiDirectoryComponent, "hsi-ui-directory", never, { "items": { "alias": "items"; "required": false; }; "level": { "alias": "level"; "required": false; }; "path": { "alias": "path"; "required": false; }; "terminalItemsAreSelectable": { "alias": "terminalItemsAreSelectable"; "required": false; }; "selectionElementRole": { "alias": "selectionElementRole"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; }, { "selectionChanges": "selectionChanges"; "stateChanges": "stateChanges"; }, never, never, true, never>;
+}

package/lib/directory/index.d.ts

@@ -0,0 +1 @@
+export * from './directory.component';

package/lib/table/index.d.ts

@@ -0,0 +1,4 @@
+export * from './table-column';
+export * from './table.component';
+export * from './table.config';
+export * from './table.module';

package/lib/table/single-sort-header/single-sort-header.component.d.ts

@@ -0,0 +1,9 @@
+import { TableColumn } from '../table-column';
+import * as i0 from "@angular/core";
+export declare class SingleSortHeaderComponent<Datum> {
+    column: TableColumn<Datum>;
+    sortIcon: string;
+    getColumnSortClasses(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSortHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SingleSortHeaderComponent<any>, "[hsi-ui-single-sort-header]", never, { "column": { "alias": "column"; "required": false; }; "sortIcon": { "alias": "sortIcon"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/table/table-column.d.ts

@@ -0,0 +1,53 @@
+export declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+export type SortDirectionType = keyof typeof SortDirection;
+export type TableValue = string | number | boolean | Date;
+export type TableCellAlignment = 'left' | 'center' | 'right';
+export declare class TableColumn<Datum> {
+    /**
+     * The label of the column. Used in the table header.
+     * */
+    label: string;
+    /**
+     * Function to extract the value to be sorted on from the datum.
+     * If not provided, the formatted value will be used for sorting.
+     */
+    getSortValue: (x: Datum) => TableValue;
+    /**
+     * Function to format the value for display in the table.
+     */
+    getFormattedValue: (x: Datum) => string;
+    /**
+     * Function to determine the alignment of the cell content.
+     */
+    getAlignment: (x: Datum) => TableCellAlignment;
+    /**
+     * Width of the column. Can be a percentage or pixel value.
+     */
+    width: string;
+    /**
+     * Function to determine the sort order of the column.
+     * If not provided, sort with use d3.ascending on the getSortValue or getFormattedValue.
+     */
+    ascendingSortFunction: (a: Datum, b: Datum) => number;
+    sortDirection: SortDirectionType;
+    /**
+     * Whether the column is sortable.
+     */
+    sortable: boolean;
+    activelySorted: boolean;
+    /**
+     * The sort order of the column. Used to determine the order of sorting when multiple columns are sorted.
+     * Sorting tiebreaks are determined by increasing sortOrder number.
+     **/
+    sortOrder: number;
+    /**
+     * Whether the column is a row header.
+     */
+    isRowHeader: boolean;
+    readonly initialSortDirection: SortDirectionType;
+    constructor(init?: Partial<TableColumn<Datum>>);
+    defaultSort(a: Datum, b: Datum): number;
+}

package/lib/table/table.component.d.ts

@@ -0,0 +1,27 @@
+import { DestroyRef, OnInit } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { TableColumn } from './table-column';
+import { HsiUiTableConfig } from './table.config';
+import * as i0 from "@angular/core";
+export declare class TableComponent<Datum> implements OnInit {
+    private destroyRef;
+    config$: Observable<HsiUiTableConfig<Datum>>;
+    sortIcon: string;
+    data$: Observable<Datum[]>;
+    columns$: Observable<TableColumn<Datum>[]>;
+    tableHeaders$: Observable<string[]>;
+    sort: BehaviorSubject<TableColumn<Datum>>;
+    sort$: Observable<TableColumn<Datum>>;
+    constructor(destroyRef: DestroyRef);
+    ngOnInit(): void;
+    setTableData(): void;
+    getMinSortOrderColumn(columns: TableColumn<Datum>[]): TableColumn<Datum>;
+    getColumnsWithNewSortApplied(activeSortColumn: TableColumn<Datum>, columns: TableColumn<Datum>[], toggleSortDirection?: boolean): TableColumn<Datum>[];
+    setTableHeaders(): void;
+    validateRowHeaders(): void;
+    sortTableByColumn(column: TableColumn<Datum>): void;
+    sortData(data: Datum[], primaryColumnSort: TableColumn<Datum>, columns: TableColumn<Datum>[]): Datum[];
+    columnTrackingFunction(_: number, column: TableColumn<Datum>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "hsi-ui-table", never, { "config$": { "alias": "config$"; "required": false; }; "sortIcon": { "alias": "sortIcon"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/table/table.config.d.ts

@@ -0,0 +1,5 @@
+import { TableColumn } from './table-column';
+export declare class HsiUiTableConfig<Datum> {
+    data: Datum[];
+    columns: TableColumn<Datum>[];
+}

package/lib/table/table.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table.component";
+import * as i2 from "./single-sort-header/single-sort-header.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/cdk/table";
+import * as i5 from "@angular/material/icon";
+export declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof i1.TableComponent, typeof i2.SingleSortHeaderComponent], [typeof i3.CommonModule, typeof i4.CdkTableModule, typeof i5.MatIconModule], [typeof i1.TableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}

package/lib/tabs/index.d.ts

@@ -0,0 +1,6 @@
+export * from './tab-body.component';
+export * from './tab-content.directive';
+export * from './tab-item.component';
+export * from './tab-label.component';
+export * from './tabs.component';
+export * from './tabs.module';

package/lib/tabs/tab-body.component.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TabBodyComponent {
+    bodyContent: TemplateRef<HTMLElement>;
+    lazyLoadedContent: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBodyComponent, "hsi-ui-tab-body", never, {}, {}, ["lazyLoadedContent"], ["*"], true, never>;
+}

package/lib/tabs/tab-content.directive.d.ts

@@ -0,0 +1,15 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { MatTabContent } from '@angular/material/tabs';
+import * as i0 from "@angular/core";
+export declare const HSI_UI_TAB_CONTENT: InjectionToken<MatTabContent>;
+/**
+ * Allows a tab to be lazy-loaded when it is activated when used as a directive on an ng-template. It is recommended that this be used when the content of the tab requires calculations.
+ *
+ * Has the same functionality as https://material.angular.io/components/tabs/overview#lazy-loading
+ */
+export declare class TabContentDirective {
+    template: TemplateRef<any>;
+    constructor(/** Content for the tab. */ template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabContentDirective, "[hsiUiTabContent]", never, {}, {}, never, never, true, never>;
+}

package/lib/tabs/tab-item.component.d.ts

@@ -0,0 +1,16 @@
+import { OnChanges } from '@angular/core';
+import { TabBodyComponent } from './tab-body.component';
+import { TabLabelComponent } from './tab-label.component';
+import { TabsService } from './tabs.service';
+import * as i0 from "@angular/core";
+export declare class TabItemComponent<T> implements OnChanges {
+    private service;
+    isActive: boolean;
+    value: T;
+    bodyComponent: TabBodyComponent;
+    labelComponent: TabLabelComponent;
+    constructor(service: TabsService<T>);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabItemComponent<any>, "hsi-ui-tab-item", never, { "isActive": { "alias": "isActive"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, ["bodyComponent", "labelComponent"], ["*"], true, never>;
+}

package/lib/tabs/tab-label.component.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TabLabelComponent {
+    value: string;
+    labelElement: ElementRef<HTMLDivElement>;
+    labelContent: TemplateRef<unknown>;
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabLabelComponent, "hsi-ui-tab-label", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/tabs/tabs.component.d.ts

@@ -0,0 +1,24 @@
+import { AfterContentInit, DestroyRef, EventEmitter, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { TabItemComponent } from './tab-item.component';
+import { TabsService } from './tabs.service';
+import * as i0 from "@angular/core";
+export declare class TabsComponent<T> implements AfterContentInit {
+    service: TabsService<T>;
+    private destroyRef;
+    tabs: QueryList<TabItemComponent<T>>;
+    tabChange: EventEmitter<string | T>;
+    tabItems$: Observable<TabItemComponent<T>[]>;
+    tabChanges$: Observable<boolean[]>;
+    constructor(service: TabsService<T>, destroyRef: DestroyRef);
+    ngAfterContentInit(): void;
+    initializeActiveTab(): void;
+    selectTab(tabItem: TabItemComponent<T>): void;
+    emitNewActiveTab(tabItem: TabItemComponent<T>): void;
+    handleKeydown(event: KeyboardEvent, tabItem: TabItemComponent<T>): void;
+    focusTab(tabItem: TabItemComponent<T>): void;
+    focusNextTab(tabIndex: number): void;
+    focusPreviousTab(tabIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent<any>, "hsi-ui-tabs", never, {}, { "tabChange": "tabChange"; }, ["tabs"], never, true, never>;
+}

package/lib/tabs/tabs.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.component";
+import * as i2 from "./tab-label.component";
+import * as i3 from "./tab-item.component";
+import * as i4 from "./tab-body.component";
+import * as i5 from "./tab-content.directive";
+export declare class TabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, never, [typeof i1.TabsComponent, typeof i2.TabLabelComponent, typeof i3.TabItemComponent, typeof i4.TabBodyComponent, typeof i5.TabContentDirective], [typeof i1.TabsComponent, typeof i2.TabLabelComponent, typeof i3.TabItemComponent, typeof i4.TabBodyComponent, typeof i5.TabContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
+}

package/lib/tabs/tabs.service.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+import { TabItemComponent } from './tab-item.component';
+import * as i0 from "@angular/core";
+export declare class TabsService<T> {
+    activeTab: BehaviorSubject<TabItemComponent<T> | null>;
+    activeTab$: import("rxjs").Observable<TabItemComponent<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabsService<any>>;
+}