@zambon-dev/library 2.0.0 → 3.0.0

package/types/zambon-dev-library.d.ts

@@ -0,0 +1,1045 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, TemplateRef, InjectionToken, OnInit, AfterViewInit, EventEmitter, ChangeDetectorRef, QueryList, PipeTransform } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { FormControl, FormGroup, FormGroupDirective, FormGroupName, AbstractControl, ValidatorFn, ValidationErrors } from '@angular/forms';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { ActivatedRoute, ActivatedRouteSnapshot } from '@angular/router';
+
+declare abstract class BaseComponent implements OnDestroy {
+    protected destroy$: Subject<boolean>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface IBatchUpdate<TEntity, TKey> {
+    entitiesToDelete: Array<TKey>;
+    entitiesToInsertOrUpdate: Array<TEntity>;
+}
+
+interface ICatalogEntry {
+    display: string;
+    value: any;
+}
+
+interface ICatalogResult {
+    entries: ICatalogEntry[];
+    shouldUseCriteria: boolean;
+}
+
+type GridConfigs = {
+    loadingDisplayText?: string;
+    messageOnEmpty?: string;
+    messageOnFailed?: string;
+    messageOnLazyLoad?: string;
+    recordBlockSize: number;
+    rowHeight: number;
+    rowsToDisplay: number;
+};
+
+type DataGridConfigs = GridConfigs & {
+    hideBorders?: boolean;
+    hideColumnHeaders?: boolean;
+    multiSelect?: boolean;
+    multiSelectSize?: string;
+    selectOnClick?: boolean;
+    showMessageOnEmpty?: boolean;
+};
+
+interface IListParameters extends ISummaryParameters {
+    endRow: number;
+    sort?: {
+        [key: string]: string;
+    };
+    startRow: number;
+}
+interface ISummaryParameters {
+    filters?: {
+        [key: string]: string;
+    };
+}
+
+interface IGridColumn {
+    customClass?: string;
+    field: string;
+    headerName: string;
+    size?: string;
+    realSize?: number;
+    template?: TemplateRef<any>;
+}
+
+interface IListResult<T> {
+    items: T[];
+    totalRows: number;
+}
+
+interface IModal {
+    size: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | 'full' | 'auto';
+    title: string;
+    get isShown(): boolean;
+    closeModal(): void;
+    toggleModal(): void;
+}
+
+interface IMultiEditorChanges {
+    changed: {
+        [key: string]: string;
+    };
+    removed: string[];
+}
+
+interface IMultiSelectorChanges {
+    idsToAdd: number[];
+    idsToRemove: number[];
+}
+
+interface IRibbonButtonOption {
+    allowedActions?: string[];
+    icon?: string;
+    id: string;
+    isAccessAllowed?: boolean;
+    isDisabled?: boolean;
+    isVisible?: boolean;
+    label: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    path?: string;
+}
+
+declare abstract class RibbonGroupChild {
+    abstract visible: boolean;
+}
+
+declare const SIDEBAR_CONFIGS: InjectionToken<SidebarConfigs>;
+declare class SidebarConfigs {
+    errorText: string;
+    /** Tooltip for items that open in a new browser tab. Rendered as-is, like {@link errorText}. */
+    externalLinkText: string;
+    loadingText: string;
+    /**
+     * Derive region headers from the menu tree instead of from {@link SidebarMenu.region}.
+     *
+     * With this on, a top-level menu that has children and no URL stops being a collapsible node
+     * and becomes an area header, with its children rendered flat beneath it as top-level items --
+     * icons included. The area is then a real menu row, so it carries its own translated label and
+     * its own order, and no `region` label has to be repeated across every item that belongs to it.
+     *
+     * Off by default: without it a top-level parent stays the collapsible group it has always been.
+     */
+    shouldDeriveAreasFromRootMenus: boolean;
+    logoCollapsedPath?: string;
+    logoExpandedPath?: string;
+    constructor(options?: Partial<SidebarConfigs>);
+}
+
+/**
+ * How a {@link SidebarMenu}'s `url` is opened when the item is clicked.
+ *
+ * Read the value off a menu through {@link toSidebarMenuOpenMode} rather than comparing the
+ * field directly: it crosses HTTP, so it can arrive as a string, as a number, as `null`, or not
+ * at all.
+ */
+declare enum SidebarMenuOpenMode {
+    /** `url` is an internal Angular route and opens an application tab. The default. */
+    Internal = "internal",
+    /** `url` is an absolute http(s) address and opens in a new browser tab. */
+    ExternalNewTab = "externalNewTab",
+    /** `url` is an absolute http(s) address and opens embedded in an application tab. */
+    ExternalEmbedded = "externalEmbedded"
+}
+/**
+ * Parses the wire value of `SidebarMenu.openMode`.
+ *
+ * Deliberately a parser rather than a `?? Internal` fallback, because the field is deserialized
+ * straight from each application's menu endpoint and its shape is not guaranteed:
+ *
+ * - a **number** is read as the backend's enum ordinal, which is what an ASP.NET Core enum
+ *   property serializes to unless that backend registers a string converter;
+ * - a **string** is matched case-insensitively, so `'externalNewTab'` and `'ExternalNewTab'`
+ *   both work;
+ * - anything else — an omitted field from a backend that predates this feature, `null`, or a
+ *   mode introduced by a newer one — degrades to {@link SidebarMenuOpenMode.Internal}.
+ *
+ * Degrading to `Internal` keeps an unrecognized mode behaving the way menus behaved before
+ * external destinations existed, instead of producing an item that does nothing when clicked.
+ */
+declare function toSidebarMenuOpenMode(value: unknown): SidebarMenuOpenMode;
+
+declare class SidebarMenu {
+    childCount: number;
+    children: SidebarMenu[];
+    height?: number;
+    icon?: string;
+    id: number;
+    label: string;
+    isSelected: boolean;
+    /**
+     * How {@link url} is opened. An absent value means {@link SidebarMenuOpenMode.Internal}.
+     *
+     * Left optional and without an initializer on purpose: the constructor is an `Object.assign`,
+     * which would overwrite a default with the `null` a nullable backend column serializes to.
+     * Read it through `toSidebarMenuOpenMode(menu.openMode)` instead of comparing it directly.
+     */
+    openMode?: SidebarMenuOpenMode;
+    parent: SidebarMenu | null;
+    region?: string;
+    url?: string;
+    constructor(options?: Partial<SidebarMenu>);
+}
+
+interface ISidebarProfile {
+    image?: string;
+    name?: string;
+    title?: string;
+}
+
+/** A named group of top-level sidebar menu items, rendered under a region header. */
+interface SidebarRegion {
+    items: SidebarMenu[];
+    name?: string;
+}
+
+interface ITabView {
+    activeView?: string;
+    title: string;
+    url: string;
+}
+
+declare class CatalogSelectComponent extends BaseComponent implements OnInit, AfterViewInit, OnDestroy {
+    protected bodyMouseDown(event: MouseEvent): void;
+    protected bodyMouseUp(event: MouseEvent): void;
+    private dropdownTemplate;
+    private inputElement;
+    autofocus: boolean;
+    controlName: string;
+    displayControlName: string;
+    displayProperty: string;
+    set entriesList(value: any[] | {
+        key: number;
+        value: Observable<any> | string;
+    }[] | null | undefined);
+    set filters(value: {
+        [id: string]: any;
+    });
+    label: string;
+    maxEntries: number;
+    minimumLengthSearch: number;
+    notes: string;
+    readOnly: boolean;
+    searchEndpoint?: string;
+    validations: {
+        [id: string]: string;
+    };
+    valueProperty: string;
+    protected displayedEntries: ICatalogEntry[];
+    protected focusedIndex: number;
+    protected isDropDownShown: boolean;
+    protected isFocused: boolean;
+    protected isLoading: boolean;
+    protected selectedValue: any;
+    protected shouldUseCriteria: boolean;
+    protected showFailureMessage: boolean;
+    protected showMinimumCharactersMessage: boolean;
+    protected showNoResultsMessage: boolean;
+    private static instanceCounter;
+    private _entriesList?;
+    private _filters;
+    private catalogService;
+    private dataGridDataset;
+    private entriesDataSource;
+    private filterDiffer?;
+    private readonly formGroup;
+    private readonly formGroupName;
+    private instanceId;
+    private isDataInitialized;
+    private isSubscriptionInitialized;
+    private keyValueDiffers;
+    private lastCriteriaUsed;
+    private overlay;
+    private overlayRef?;
+    private positionBuilder;
+    private searchSubject;
+    private viewContainerRef;
+    private wasClickedOutside;
+    get entriesList(): any[] | {
+        key: number;
+        value: Observable<any> | string;
+    }[] | null | undefined;
+    get filters(): {
+        [id: string]: any;
+    } | undefined;
+    protected get activeDescendantId(): string | null;
+    protected get displayControl(): FormControl;
+    protected get formControl(): FormControl;
+    protected get formControlName(): string;
+    protected get formDisplayControlName(): string;
+    protected get isInvalid(): boolean;
+    protected get isTouched(): boolean;
+    protected get listboxId(): string;
+    protected get showClearButton(): boolean;
+    private get hasSearchEndpoint();
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    protected onContainerBlur(): void;
+    protected onContainerClick(): void;
+    protected onContainerFocus(): void;
+    protected onClearClick(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onDropDownErrorClick(): void;
+    protected onDropDownItemClick(entry: ICatalogEntry): void;
+    protected getOptionId(index: number): string;
+    private applySearchCriteria;
+    private checkAndAddDisplayControl;
+    private closeDropdownOverlay;
+    private initializeEntriesDataSource;
+    private initializeSearch;
+    private openDropdownOverlay;
+    private refreshSearch;
+    private resetMessages;
+    private resolveDisplay;
+    private syncDisplayFromCurrentValue;
+    /**
+     * Decides whether the display control has to be written again.
+     *
+     * The value on its own is not enough. Resetting a form clears the display control and then
+     * patches the same value back, so an unchanged value can still leave the display empty. That
+     * only happens when the stored value equals the control's initial value, which is why it used
+     * to show up on the default entry alone.
+     */
+    private shouldRefreshDisplay;
+    private syncFormControlsEnabledDisabled;
+    private tryFilterFromDataset;
+    private updateFilters;
+    private updateMinimumCharactersMessageVisibility;
+    private getNativeInput;
+    private scrollFocusedItemIntoView;
+    private setInputAriaAttributes;
+    private updateInputAriaActiveDescendant;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSelectComponent, "lib-catalog-select", never, { "autofocus": { "alias": "autofocus"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; "displayControlName": { "alias": "displayControlName"; "required": false; }; "displayProperty": { "alias": "displayProperty"; "required": false; }; "entriesList": { "alias": "entriesList"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "label": { "alias": "label"; "required": false; }; "maxEntries": { "alias": "maxEntries"; "required": false; }; "minimumLengthSearch": { "alias": "minimumLengthSearch"; "required": false; }; "notes": { "alias": "notes"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "searchEndpoint": { "alias": "searchEndpoint"; "required": false; }; "validations": { "alias": "validations"; "required": false; }; "valueProperty": { "alias": "valueProperty"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CatalogService {
+    private http;
+    search(endpoint: string, maxResults: number, criteria?: string, filters?: {
+        [key: string]: string;
+    } | null): Observable<ICatalogResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class DataProviderService<TEntityModel> implements OnDestroy {
+    protected activatedRoute: ActivatedRoute;
+    protected destroy$: Subject<boolean>;
+    protected shouldLazyLoad: boolean;
+    private _entityID?;
+    private errorSubject;
+    private isLoading;
+    private isModelLoaded;
+    private modelCache;
+    get entityID(): number | undefined;
+    get hasEntityID(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    getError$(): Observable<HttpErrorResponse>;
+    abstract getTitle(entity: TEntityModel): string;
+    getModel$(): Observable<TEntityModel | null>;
+    refreshModel(): void;
+    resetForNewEntity(): void;
+    abstract saveModel(model: any): Observable<TEntityModel>;
+    updateModel(model: any): void;
+    protected abstract loadModel(entityID?: number): Observable<TEntityModel | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataProviderService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class BaseDataset implements OnDestroy {
+    protected dataProvider: DataProviderService<any> | null;
+    protected destroy$: Subject<boolean>;
+    private _parentEntityId?;
+    get parentEntityId(): any;
+    set parentEntityId(value: any);
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDataset, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class GridConfigsProvider<TGridConfigs extends GridConfigs = GridConfigs> {
+    protected _configs: TGridConfigs;
+    get configs(): TGridConfigs;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridConfigsProvider<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class GridDataset extends BaseDataset {
+    configs: GridConfigs;
+    filtersChanged: EventEmitter<{
+        [key: string]: string;
+    }>;
+    isLoading: boolean;
+    loadedLastRow: boolean;
+    loadFinished: EventEmitter<boolean>;
+    loadStarted: EventEmitter<void>;
+    totalRows?: number;
+    protected compareProperty: string;
+    protected configsProvider: GridConfigsProvider;
+    protected focusedRow: string | null;
+    protected recordBlock: number;
+    private _hasBeenLoaded;
+    private _loadedKeys?;
+    private _loadedRows?;
+    private queryFilters?;
+    get filters(): {
+        [key: string]: string;
+    } | undefined;
+    get hasBeenLoaded(): boolean;
+    get hasLoadedRows(): boolean;
+    get keyProperty(): string;
+    get loadedKeys(): string[] | undefined;
+    get loadedRows(): any[] | undefined;
+    get parentEntityId(): any;
+    set parentEntityId(value: any);
+    constructor();
+    addNewRow(row: any): void;
+    /** The key of the currently focused row, or null. Read by DataGridRowComponent's host binding. */
+    get focusedRowKey(): string | null;
+    clearFocusedRow(): void;
+    getRowData(key: string): any | null;
+    getRowID(key: string): any;
+    getRowInternalKey(row: any): string;
+    hasRowWithID(id: any): boolean;
+    isKeyExists(key: string): boolean;
+    loadRows(): void;
+    refresh(): void;
+    removeKeys(keys: string[]): void;
+    setFilters(filters?: {
+        [key: string]: string;
+    }): void;
+    setFocusedRow(key: string): void;
+    updateRow(key: string, newRowData: any): void;
+    protected clearLoadedRows(): void;
+    protected updateLoadedRows(rows: any[]): void;
+    abstract getData(params?: any): Observable<any[] | {
+        items: any[];
+        totalRows: number;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridDataset, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class DataGridDataset extends GridDataset {
+    selectedRowsChanged: EventEmitter<{
+        [id: string]: {
+            rowData: any;
+            selected: boolean;
+        };
+    }>;
+    columns: IGridColumn[];
+    configs: DataGridConfigs;
+    selectedRowKeys: string[];
+    get columnsSize(): string;
+    get hasSelectedRows(): boolean;
+    constructor();
+    clearSelection(): void;
+    export(_format: string, _parameters: IListParameters): Observable<HttpResponse<Blob>>;
+    deselectRow(key: string): void;
+    deselectRowID(id: any): void;
+    getSelectedRowsData(): any[];
+    isKeySelected(key: any): boolean;
+    refresh(): void;
+    removeKeys(keys: string[]): void;
+    selectRow(key: string): void;
+    selectRowID(id: any): void;
+    selectRows(keys: string[]): void;
+    setFocusedRow(key: any): void;
+    protected removeSelectedRow(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridDataset, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class MultiEditorDataset extends BaseDataset {
+    savedChanges: EventEmitter<void>;
+    protected readonly dataGridDataset: DataGridDataset;
+    private fakeIDsGenerated;
+    private modifiedValues;
+    constructor();
+    clearChangedValues(): void;
+    removeValue(key: string): void;
+    saveChanges(): Observable<any>;
+    storeFakeIDGenerated(id: any): void;
+    updateValues(key: string, newRowData: any): void;
+    abstract newData(id: any): any;
+    abstract saveData(batchUpdate: IBatchUpdate<any, any>): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiEditorDataset, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class MultiSelectResultDataset extends GridDataset {
+    savedChanges: EventEmitter<void>;
+    displayedIDs: any[];
+    displayedRows: any[];
+    private _idsToAdd;
+    private _idsToRemove;
+    private addedRowData;
+    get idsToAdd(): any[];
+    get idsToRemove(): any[];
+    refresh(): void;
+    saveChanges(): Observable<any>;
+    setIDToAdd(idToAdd: any, rowData: any): void;
+    setIDToRemove(idToRemove: any): void;
+    protected updateLoadedRows(rows: any[]): void;
+    private clearSelection;
+    private isExistingID;
+    private updateDisplayedRows;
+    protected abstract saveData(changedIds: IMultiSelectorChanges): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectResultDataset, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class FormGroupService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class FormService {
+    fieldRefreshed: EventEmitter<{
+        fieldName: string;
+        value?: any;
+        loading?: boolean;
+    }>;
+    modelRefreshed: EventEmitter<any>;
+    private _loading;
+    private _model;
+    private currentMode;
+    private editCanceled$;
+    private form?;
+    private initialValue?;
+    get editCanceled(): Observable<void>;
+    get isEditMode(): boolean;
+    get isValid(): boolean;
+    get loading(): boolean;
+    set loading(value: boolean);
+    get model(): any | null;
+    set model(value: any | null);
+    beginEdit(): void;
+    beginFieldLoading(fieldName: string): void;
+    cancelEdit(): void;
+    disableForm(): void;
+    enableForm(): void;
+    getModelFromForm(): any;
+    initializeForm(form: FormGroup): void;
+    markAllAsTouched(): void;
+    resetForm(): void;
+    setFieldValue(fieldName: string, value: any): void;
+    setValidationErrorsFromHttpResponse(errorResponse: HttpErrorResponse): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare abstract class SidebarService {
+    childrenFailed: EventEmitter<SidebarMenu>;
+    childrenLoading: EventEmitter<SidebarMenu>;
+    childrenInitialized: EventEmitter<SidebarMenu>;
+    menuExternalUrlSelected: EventEmitter<SidebarMenu>;
+    menuUrlSelected: EventEmitter<SidebarMenu>;
+    selectionChanged: EventEmitter<SidebarMenu>;
+    isActive: boolean;
+    isCollapsed: boolean;
+    shouldActivate: boolean;
+    private menus;
+    private selectedMenu;
+    deselectAll(): void;
+    loadChildren(parentMenu: SidebarMenu): void;
+    /**
+     * Loads a parent's children and hands them back, for callers that need them before the user
+     * clicks -- a sidebar rendering areas flat has to have them up front. {@link loadChildren} is
+     * the fire-and-forget variant that also raises the loading and failure events.
+     */
+    loadChildrenFor(parentMenu: SidebarMenu): Observable<SidebarMenu[]>;
+    loadRoot(): Observable<SidebarMenu[]>;
+    select(menu: SidebarMenu): void;
+    private deselectMenu;
+    private selectMenu;
+    abstract getMenuFromUrl(url: string): Observable<SidebarMenu>;
+    abstract getUserProfile(): ISidebarProfile | undefined;
+    protected abstract loadMenus(parentMenuID: SidebarMenu | null): Observable<SidebarMenu[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class DataGridComponent extends BaseComponent implements OnInit, AfterViewInit, OnDestroy {
+    private bodyElement;
+    private viewport?;
+    disabled: boolean;
+    lazyLoadRows: boolean;
+    showButtons: boolean;
+    protected changeDetectorRef: ChangeDetectorRef;
+    protected dataGridDataset: DataGridDataset;
+    protected hasFailed: boolean;
+    protected headerRightMargin: number;
+    protected headerScrollLeft: number;
+    protected loading: boolean;
+    private bodyResized$;
+    private bodyResizeObserver?;
+    private gridRoute;
+    private isGridCurrentUrl;
+    private lastPosition;
+    private ngZone;
+    private router;
+    private selectionColRealSize?;
+    protected get bodyMinHeight(): number;
+    protected get columns(): IGridColumn[];
+    protected get configs(): DataGridConfigs;
+    protected get gridColumns(): string;
+    protected get hasBeenLoaded(): boolean;
+    protected get hasLoadedRows(): boolean;
+    protected get hasMessageToDisplayWhenEmpty(): boolean;
+    protected get isHideColumns(): boolean;
+    protected get isShowMultiSelect(): boolean;
+    protected get messageToDisplayWhenEmpty(): string;
+    protected get messageToDisplayWhenLazyLoad(): string;
+    protected get messageToDisplayWhenFailed(): string;
+    protected get selectionColWidth(): string;
+    protected get shouldDisplayMessageWhenEmpty(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected onSelectionResized(newSize: number): void;
+    protected isFirstVisibleRow(rowIndex: number): boolean;
+    private syncHeaderScroll;
+    protected trackByFn(index: number, item: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataGridComponent, "lib-data-grid", never, { "disabled": { "alias": "disabled"; "required": false; }; "lazyLoadRows": { "alias": "lazyLoadRows"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; }, {}, never, ["[buttons]"], true, never>;
+}
+
+declare class DataGridRowComponent extends BaseComponent implements OnInit {
+    disabled: boolean;
+    isFirstRow: boolean;
+    set rowData(value: any);
+    selectionResized: EventEmitter<number>;
+    setFocus(): void;
+    protected changeDetectorRef: ChangeDetectorRef;
+    protected dataGridDataset: DataGridDataset;
+    protected selected: boolean;
+    private _rowData;
+    private elementRef;
+    get rowData(): any;
+    protected get columns(): IGridColumn[];
+    private get isLaidOut();
+    private get isRowDataSelected();
+    protected get rowKey(): string;
+    constructor();
+    ngOnInit(): void;
+    protected onResize(colIndex: number, event: ResizeObserverEntry): void;
+    protected onResizeSelection(event: ResizeObserverEntry): void;
+    protected onToggleSelection(): void;
+    protected getValue(field: string): any;
+    private refreshSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataGridRowComponent, "lib-data-grid-row", never, { "disabled": { "alias": "disabled"; "required": false; }; "isFirstRow": { "alias": "isFirstRow"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; }, { "selectionResized": "selectionResized"; }, never, never, true, never>;
+}
+
+declare class FormInputComponent extends BaseComponent implements OnInit {
+    autofocus: boolean;
+    controlName: string;
+    disabledControlName?: string;
+    displayReadOnlyAsDisabled: boolean;
+    fixedValue?: any;
+    format?: string;
+    invalid: boolean;
+    isDisabled: boolean;
+    isFullHeight: boolean;
+    maxLength?: number;
+    min?: number;
+    readOnly: boolean;
+    rows: number;
+    step: number;
+    type: string;
+    blurred: EventEmitter<void>;
+    changed: EventEmitter<any>;
+    fixedValueChanged: EventEmitter<string>;
+    focused: EventEmitter<void>;
+    inputChanged: EventEmitter<void>;
+    protected readonly formGroupDirective: FormGroupDirective;
+    protected readonly formGroupName: FormGroupName;
+    protected readonly formService: FormService;
+    protected get formControl(): FormControl<any> | null;
+    protected get formControlName(): string;
+    protected get formGroup(): FormGroup;
+    protected get isFormControl(): boolean;
+    protected get isFormEditMode(): boolean;
+    protected get parentGroups(): string[];
+    protected get stepAttributeValue(): number | null;
+    protected get minAttributeValue(): number | null;
+    constructor();
+    ngOnInit(): void;
+    protected onBlur(): void;
+    protected onChange(value: any): void;
+    protected onFocus(): void;
+    protected onInput(): void;
+    protected onValueChanged(newText: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormInputComponent, "lib-form-input", never, { "autofocus": { "alias": "autofocus"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; "disabledControlName": { "alias": "disabledControlName"; "required": false; }; "displayReadOnlyAsDisabled": { "alias": "displayReadOnlyAsDisabled"; "required": false; }; "fixedValue": { "alias": "fixedValue"; "required": false; }; "format": { "alias": "format"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isFullHeight": { "alias": "isFullHeight"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "step": { "alias": "step"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "blurred": "blurred"; "changed": "changed"; "fixedValueChanged": "fixedValueChanged"; "focused": "focused"; "inputChanged": "inputChanged"; }, never, never, true, never>;
+}
+
+declare class FormInputGroupComponent extends BaseComponent implements OnInit {
+    autofocus: boolean;
+    alignContent: 'center' | 'end' | 'start';
+    controlName: string;
+    fixedValue?: any;
+    format?: string;
+    label: string;
+    isDisabled: boolean;
+    isFullHeight: boolean;
+    maxLength?: number;
+    min?: number;
+    notes: string;
+    readOnly: boolean;
+    rows: number;
+    showLabel: boolean;
+    step: number;
+    template: TemplateRef<any>;
+    type: string;
+    validations: {
+        [id: string]: string;
+    };
+    protected readonly formGroupDirective: FormGroupDirective;
+    protected readonly formGroupName: FormGroupName;
+    protected formService: FormService;
+    protected loadingField: boolean;
+    protected get formControl(): FormControl<any> | null;
+    protected get formGroup(): FormGroup;
+    protected get hasNotes(): boolean;
+    protected get parentGroups(): string[];
+    constructor();
+    ngOnInit(): void;
+    protected hasValidation(errorKey: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormInputGroupComponent, "lib-form-input-group", never, { "autofocus": { "alias": "autofocus"; "required": false; }; "alignContent": { "alias": "alignContent"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; "fixedValue": { "alias": "fixedValue"; "required": false; }; "format": { "alias": "format"; "required": false; }; "label": { "alias": "label"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isFullHeight": { "alias": "isFullHeight"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "notes": { "alias": "notes"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "step": { "alias": "step"; "required": false; }; "template": { "alias": "template"; "required": false; }; "type": { "alias": "type"; "required": false; }; "validations": { "alias": "validations"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormGroupComponent {
+    shouldExpand: boolean;
+    label: string;
+    protected get hasTitle(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupComponent, "lib-form-group", never, { "shouldExpand": { "alias": "shouldExpand"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class GroupAccordionComponent {
+    private containerElementRef;
+    label: string;
+    private _maxHeight;
+    protected collapsed: boolean;
+    get maxHeight(): number;
+    protected onToggle(): void;
+    private clearMaxHeight;
+    private setMaxHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupAccordionComponent, "lib-group-accordion", never, { "label": { "alias": "label"; "required": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollSpyDirective implements AfterViewInit {
+    spiedTags: Array<string>;
+    activeSectionChange: EventEmitter<number>;
+    private _el;
+    private activeSection;
+    private sections;
+    ngAfterViewInit(): void;
+    onScroll(event: any): void;
+    scrollTo(section: number): void;
+    select(section: number): void;
+    private updateSections;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollSpyDirective, "[libScrollSpy]", never, { "spiedTags": { "alias": "spiedTags"; "required": false; }; }, { "activeSectionChange": "activeSectionChange"; }, never, never, true, never>;
+}
+
+declare class GroupContainerComponent {
+    scrollSpy: ScrollSpyDirective;
+    sections: QueryList<GroupAccordionComponent>;
+    get titles(): string[];
+    activeSection: number;
+    title?: string;
+    icon?: string;
+    activeSectionChanged(index: number): void;
+    scrollTo(section: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupContainerComponent, "lib-group-container", never, { "title": { "alias": "title"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, ["sections"], ["*"], true, never>;
+}
+
+declare class GroupScrollSpyComponent {
+    scrollSpy: ScrollSpyDirective;
+    sections: QueryList<GroupAccordionComponent>;
+    get titles(): string[];
+    activeSection: number;
+    activeSectionChanged(index: number): void;
+    scrollTo(section: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupScrollSpyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupScrollSpyComponent, "lib-group-scroll-spy", never, {}, {}, ["sections"], ["*"], true, never>;
+}
+
+declare class ModalComponent extends BaseComponent implements IModal {
+    closeButtonText: string;
+    dialog: boolean;
+    modalProcessing: boolean;
+    position: 'top' | 'left' | 'right' | 'bottom' | 'center';
+    size: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | 'full' | 'auto';
+    title: string;
+    closed: EventEmitter<void>;
+    private _show;
+    private clickedOutside;
+    private elementRef;
+    get isShown(): boolean;
+    constructor();
+    protected onCloseClick(): void;
+    closeModal(): void;
+    toggleModal(): void;
+    protected bodyMouseDown(event: MouseEvent): void;
+    protected bodyMouseUp(event: MouseEvent): void;
+    protected documentKeyDown(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "lib-modal", never, { "closeButtonText": { "alias": "closeButtonText"; "required": false; }; "dialog": { "alias": "dialog"; "required": false; }; "modalProcessing": { "alias": "modalProcessing"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, { "closed": "closed"; }, never, ["[body]", "[footer]"], true, never>;
+}
+
+declare class MultiEditorComponent extends ModalComponent implements OnInit {
+    private modal;
+    addButtonLabel: string;
+    formGroup: FormGroup<any>;
+    removeButtonLabel: string;
+    showAddButton: boolean;
+    showDeleteButton: boolean;
+    protected gridLoading: boolean;
+    private dataGridDataset;
+    private formService;
+    private multiEditorDataset;
+    private selectedKey?;
+    private selectedValue?;
+    protected get formLoading(): boolean;
+    protected get hasSelectedKey(): boolean;
+    constructor();
+    ngOnInit(): void;
+    protected onDeleteClick(): void;
+    protected onNewClick(): void;
+    protected onSaveClick(): void;
+    closeModal(): void;
+    toggleModal(): void;
+    private clearAllFormArrays;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiEditorComponent, "lib-multi-editor", never, { "addButtonLabel": { "alias": "addButtonLabel"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "removeButtonLabel": { "alias": "removeButtonLabel"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "showDeleteButton": { "alias": "showDeleteButton"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MultiSelectComponent extends ModalComponent implements OnInit {
+    private modal;
+    itemTemplate: TemplateRef<any>;
+    protected isResultGridLoading: boolean;
+    protected isSearchGridLoading: boolean;
+    protected resultDataset: MultiSelectResultDataset;
+    protected searchCriteria: string;
+    private _searchColumn;
+    private dataGridDataset;
+    private get searchColumn();
+    constructor();
+    ngOnInit(): void;
+    protected onSave(): void;
+    protected onSearch(): void;
+    closeModal(): void;
+    toggleModal(): void;
+    private clearSearch;
+    private updateSelectedItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectComponent, "lib-multi-select", never, { "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MultiSelectResultGridComponent extends BaseComponent implements OnInit {
+    isDisabled: boolean;
+    template: TemplateRef<any>;
+    protected dataGridDataset: DataGridDataset;
+    protected isLoading: boolean;
+    protected resultDataset: MultiSelectResultDataset;
+    constructor();
+    ngOnInit(): void;
+    onItemRemoved(rowIndex: number): void;
+    protected onScrolled(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectResultGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectResultGridComponent, "lib-multi-select-result-grid", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SidebarComponent extends BaseComponent implements AfterViewInit, OnInit {
+    protected onBodyMouseDown(event: MouseEvent): void;
+    protected onBodyMouseUp(_event: MouseEvent): void;
+    protected onDocumentKeyDown(event: Event): void;
+    protected onResize(_event: Event): void;
+    private sidebarConfigs;
+    protected configErrorText: string;
+    protected configLoadingText: string;
+    protected hasFailed: boolean;
+    protected menus: SidebarMenu[];
+    protected regions: SidebarRegion[];
+    private sidebarService;
+    private wasClickedOutside;
+    protected get isActive(): boolean;
+    protected get isCollapsed(): boolean;
+    protected get isLoading(): boolean;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    collapse(): void;
+    protected trackByFn(_index: number, item: SidebarMenu): number;
+    protected trackByRegion(_index: number, region: SidebarRegion): string;
+    /** Whether this top-level menu stands for an area rather than a destination of its own. */
+    private isArea;
+    private groupByRegionLabel;
+    private groupByRootMenus;
+    private groupIntoRegions;
+    /**
+     * Fetches the children of every area up front, because they are rendered flat rather than
+     * behind a click, so the lazy load a collapsible parent relies on would never be triggered.
+     */
+    private loadAreaChildren;
+    private deactivate;
+    private updateShouldActivate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "lib-sidebar", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RibbonButtonComponent {
+    color: string;
+    defaultOption: number;
+    disabled: boolean;
+    icon?: string;
+    iconSize: 'small' | 'large';
+    label: string;
+    loading: boolean;
+    options: IRibbonButtonOption[];
+    tooltip: string;
+    action: EventEmitter<string | undefined>;
+    protected bodyMouseDown(event: MouseEvent): void;
+    protected bodyMouseUp(event: MouseEvent): void;
+    protected documentKeyDown(event: Event): void;
+    protected showDropdown: boolean;
+    protected status: null | 'failure' | 'warning' | 'success';
+    private clickedOutside;
+    protected get buttonIcon(): string;
+    protected get isButtonDisabled(): boolean;
+    protected onButtonClicked(): void;
+    protected onOptionClicked(option: IRibbonButtonOption): void;
+    protected onShowHideDropdown(): void;
+    finishLoading(status: 'failure' | 'warning' | 'success'): void;
+    startLoading(): void;
+    protected isOptionDisabled(option: IRibbonButtonOption): boolean;
+    protected isOptionVisible(option: IRibbonButtonOption): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RibbonButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RibbonButtonComponent, "lib-ribbon-button", never, { "color": { "alias": "color"; "required": false; }; "defaultOption": { "alias": "defaultOption"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSize": { "alias": "iconSize"; "required": false; }; "label": { "alias": "label"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "options": { "alias": "options"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+declare class RibbonComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RibbonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RibbonComponent, "lib-ribbon", never, {}, {}, never, ["*", "[right]"], true, never>;
+}
+
+declare class RibbonGroupComponent {
+    children?: QueryList<RibbonGroupChild>;
+    label: string;
+    protected get hasChildren(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RibbonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RibbonGroupComponent, "lib-ribbon-group", never, { "label": { "alias": "label"; "required": false; }; }, {}, ["children"], ["*"], true, never>;
+}
+
+declare class DateHelpers {
+    static diffDays(initialDate: Date, finalDate: Date): number;
+}
+
+/**
+ * Tracks the form controls that exist only to show a catalog selection's label.
+ *
+ * `lib-catalog-select` works in pairs: the control named by `controlName` holds the identifier, and
+ * the one named by `displayControlName` holds the text the user reads. The second is created by the
+ * component itself when a screen does not declare it, so a form ends up carrying controls nobody
+ * wrote down — and a filters form then submits them alongside the real filters.
+ *
+ * The mark lives in a `WeakSet` keyed by the control instance rather than by its name. That is the
+ * only scope that is actually correct: two forms may each have an `employeeName`, and only the one
+ * a catalog select drives is a display control. It also keeps nothing alive.
+ */
+declare class DisplayControls {
+    private static readonly marked;
+    /**
+     * Whether the control exists only to display a catalog selection's label.
+     *
+     * @param control The control, which may be absent.
+     * @returns `true` when a catalog select drives it as its display control.
+     */
+    static isDisplayControl(control: AbstractControl | null | undefined): boolean;
+    /**
+     * Marks the control as existing only to display a catalog selection's label.
+     *
+     * @param control The control, which may be absent.
+     */
+    static markAsDisplayControl(control: AbstractControl | null | undefined): void;
+}
+
+declare class GuidHelper {
+    static generateGUID(): string;
+}
+
+declare abstract class RouterFormatter {
+    static getURL(route: ActivatedRouteSnapshot): string;
+}
+
+declare class EnumTranslatePipe implements PipeTransform {
+    private translate;
+    transform(enumType: any): Array<{
+        value: any;
+        display: Observable<any>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnumTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EnumTranslatePipe, "enumTranslate", true>;
+}
+
+declare class ReplacePipe implements PipeTransform {
+    transform(message: string, searchValue: string, replaceValue?: string | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReplacePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReplacePipe, "replace", true>;
+}
+
+declare class ReplaceManyPipe implements PipeTransform {
+    transform(message: string, replaceArgs?: {
+        [id: string]: string | null | undefined;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReplaceManyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReplaceManyPipe, "replaceMany", true>;
+}
+
+declare class LibraryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibraryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LibraryModule, never, [typeof CatalogSelectComponent, typeof DataGridComponent, typeof DataGridRowComponent, typeof FormInputComponent, typeof FormInputGroupComponent, typeof FormGroupComponent, typeof GroupAccordionComponent, typeof GroupContainerComponent, typeof GroupScrollSpyComponent, typeof SidebarComponent, typeof ModalComponent, typeof MultiEditorComponent, typeof MultiSelectComponent, typeof MultiSelectResultGridComponent, typeof RibbonComponent, typeof RibbonButtonComponent, typeof RibbonGroupComponent, typeof ScrollSpyDirective, typeof EnumTranslatePipe, typeof ReplacePipe, typeof ReplaceManyPipe], [typeof CatalogSelectComponent, typeof DataGridComponent, typeof DataGridRowComponent, typeof FormInputComponent, typeof FormInputGroupComponent, typeof FormGroupComponent, typeof GroupAccordionComponent, typeof GroupContainerComponent, typeof GroupScrollSpyComponent, typeof SidebarComponent, typeof ModalComponent, typeof MultiEditorComponent, typeof MultiSelectComponent, typeof MultiSelectResultGridComponent, typeof RibbonComponent, typeof RibbonButtonComponent, typeof RibbonGroupComponent, typeof ScrollSpyDirective, typeof EnumTranslatePipe, typeof ReplacePipe, typeof ReplaceManyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LibraryModule>;
+}
+
+declare class DataGridConfigsProvider extends GridConfigsProvider<DataGridConfigs> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridConfigsProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+declare class DateValidators {
+    static greaterThanControl(controlName: string): ValidatorFn;
+    static greaterThanOrEqualControl(controlName: string): ValidatorFn;
+    static greaterThanOrEqualToday(control: AbstractControl): ValidationErrors | null;
+    static greaterThanToday(control: AbstractControl): ValidationErrors | null;
+    static lessThanControl(controlName: string): ValidatorFn;
+    static lessThanOrEqualControl(controlName: string): ValidatorFn;
+    static lessThanOrEqualToday(control: AbstractControl): ValidationErrors | null;
+    static lessThanToday(control: AbstractControl): ValidationErrors | null;
+    static maxDate(maxDate: Date): ValidatorFn;
+    static minDate(minDate: Date): ValidatorFn;
+}
+
+export { BaseComponent, BaseDataset, CatalogSelectComponent, CatalogService, DataGridComponent, DataGridConfigsProvider, DataGridDataset, DataGridRowComponent, DataProviderService, DateHelpers, DateValidators, DisplayControls, EnumTranslatePipe, FormGroupComponent, FormGroupService, FormInputComponent, FormInputGroupComponent, FormService, GridConfigsProvider, GridDataset, GroupAccordionComponent, GroupContainerComponent, GroupScrollSpyComponent, GuidHelper, LibraryModule, ModalComponent, MultiEditorComponent, MultiEditorDataset, MultiSelectComponent, MultiSelectResultDataset, MultiSelectResultGridComponent, ReplaceManyPipe, ReplacePipe, RibbonButtonComponent, RibbonComponent, RibbonGroupChild, RibbonGroupComponent, RouterFormatter, SIDEBAR_CONFIGS, ScrollSpyDirective, SidebarComponent, SidebarConfigs, SidebarMenu, SidebarMenuOpenMode, SidebarService, toSidebarMenuOpenMode };
+export type { DataGridConfigs, GridConfigs, IBatchUpdate, ICatalogEntry, ICatalogResult, IGridColumn, IListParameters, IListResult, IModal, IMultiEditorChanges, IMultiSelectorChanges, IRibbonButtonOption, ISidebarProfile, ISummaryParameters, ITabView, SidebarRegion };