@entake/particle 19.1.3 → 20.0.1

package/index.d.ts

@@ -1,5 +1,3852 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, ElementRef, OnChanges, AfterViewInit, OnInit, QueryList, EventEmitter, AfterContentInit, Renderer2, PipeTransform } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Subject, Observable } from 'rxjs';
+import { Editor } from '@tiptap/core';
+import { AnimationEvent } from '@angular/animations';
+import * as _entake_particle from '@entake/particle';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpClient, HttpParams, HttpErrorResponse } from '@angular/common/http';
+
+declare class ParticleIconsModule {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParticleIconsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ParticleIconsModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ParticleIconsModule>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Directive to create a tooltip around the host element
+ * TODO: Open/Close animation with AnimationFactory
  */
-/// <amd-module name="@entake/particle" />
-export * from './public_api';
+declare class TooltipDirective implements OnDestroy {
+    private element;
+    private renderer;
+    /**
+     * The number of pixels from the host to offset the tooltip
+     * @private
+     */
+    private readonly TOOLTIP_OFFSET;
+    /**
+     * Tooltip text input
+     * @param text the text to set for the tooltip
+     */
+    set particleTooltip(text: string);
+    get particleTooltip(): string;
+    /**
+     * The direction of the tooltip around the host element
+     */
+    readonly tooltipPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    /**
+     * Whether to disable the tooltip
+     * @param disabled disabled or not
+     */
+    set tooltipDisabled(disabled: boolean);
+    get tooltipDisabled(): boolean;
+    /**
+     * The DIV element housing the tooltip
+     * @private
+     */
+    private tooltip;
+    /**
+     * The tooltip text
+     * @private
+     */
+    private _text;
+    /**
+     * Whether or not the tooltip is disabled
+     * @private
+     */
+    private _tooltipDisabled;
+    /**
+     * Array of scroll unlisten functions
+     * @private
+     */
+    private scrollUnlisteners;
+    /**
+     * Get window scroll top
+     * @private
+     */
+    private static getWindowScrollTop;
+    /**
+     * Get window scroll left
+     * @private
+     */
+    private static getWindowScrollLeft;
+    /**
+     * Destroy directive, invoke scroll unlisteners
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle host mouse enter event
+     */
+    onMouseEnter(): void;
+    /**
+     * Handle host mouse leave event
+     */
+    onMouseLeave(): void;
+    /**
+     * Handle host click event
+     */
+    onClick(): void;
+    /**
+     * Create tooltip, set the text and align it
+     * @private
+     */
+    private showTooltip;
+    /**
+     * Add the tooltip to the DOM
+     * @private
+     */
+    private createTooltip;
+    /**
+     * Set tooltip text
+     * @private
+     */
+    private setTooltipText;
+    /**
+     * Align the tooltip to the input position or the next best fit
+     * @private
+     */
+    private alignTooltip;
+    /**
+     * Align the tooltip to the left of the host
+     * @private
+     */
+    private alignLeft;
+    /**
+     * Align the tooltip to the right of the host
+     * @private
+     */
+    private alignRight;
+    /**
+     * Align the tooltip to the top of the host
+     * @private
+     */
+    private alignTop;
+    /**
+     * Align the tooltip to the bottom of the host
+     * @private
+     */
+    private alignBottom;
+    /**
+     * Get the host's top and left position offset by window scroll
+     * @private
+     */
+    private getHostOffset;
+    /**
+     * Remove the tooltip from the DOM
+     * @private
+     */
+    private deleteTooltip;
+    /**
+     * Checks if the tooltip fits in the window
+     * @private
+     */
+    private tooltipOutOfWindow;
+    /**
+     * Listen for scrolling on all scrollable parents of the host element
+     * @private
+     */
+    private addScrollListeners;
+    /**
+     * Invoke scroll unlisten functions and clear unlisteners list
+     * @private
+     */
+    private removeScrollListeners;
+    /**
+     * Get the parent elements for the input element
+     * @param element the element to get parents for
+     * @param parents the parent elements
+     * @private
+     */
+    private getParentElements;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[particleTooltip]", never, { "particleTooltip": { "alias": "particleTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to apply key filtering to an HTML input element
+ */
+declare class KeyfilterDirective {
+    private hostElement;
+    /**
+     * Array of keyboard key names that are always allowed
+     * (arrow keys, backspace, delete, tab, escape)
+     * @private
+     */
+    private static readonly ALLOWED_KEYS;
+    /**
+     * Array of keyboard alpha key names
+     * @private
+     */
+    private static readonly ALPHA_KEYS;
+    /**
+     * Array of keyboard alpha key names
+     * @private
+     */
+    private static readonly URL_TOKEN_KEYS;
+    /**
+     * The type of filtering to apply
+     */
+    filterType: 'alpha' | 'numeric' | 'alphanumeric' | 'digits' | 'url-token';
+    /**
+     * Whether spaces should be allowed (default false)
+     */
+    allowSpaces: boolean;
+    /**
+     * Determine if the input key is numeric (a digit)
+     * @param key the key to test
+     * @private
+     */
+    private static keyIsNumeric;
+    private static keyIsDigit;
+    private static valueIsNumeric;
+    /**
+     * Determine if the input key is an alpha key (a letter of
+     * the English alphabet)
+     * @param key the key to test
+     * @private
+     */
+    private static keyIsAlpha;
+    private static keyIsUrlToken;
+    /**
+     * Filter out keys based on the specified filter type
+     * @param event the keydown KeyboardEvent
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Prevent paste if input contains forbidden characters
+     * @param event the paste ClipboardEvent
+     */
+    onPaste(event: ClipboardEvent): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyfilterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KeyfilterDirective, "[particleKeyfilter]", never, { "filterType": { "alias": "particleKeyfilter"; "required": false; }; "allowSpaces": { "alias": "allowSpaces"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AccordionContentDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContentDirective, "[particleAccordionContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AccordionHeaderDirective {
+    templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionHeaderDirective, "[particleAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AccordionItemDirective {
+    header: string;
+    disabled: boolean;
+    open: boolean;
+    headerClass: string;
+    headerTemplate: AccordionHeaderDirective;
+    content: AccordionContentDirective;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionItemDirective, "particle-accordion-item", never, { "header": { "alias": "header"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; "headerClass": { "alias": "headerClass"; "required": false; }; }, {}, ["headerTemplate", "content"], never, true, never>;
+}
+
+/**
+ * Carousel Options for the Background Carousel Directive
+ */
+interface CarouselOptions {
+    /**
+     * Image locations to loop through
+     */
+    images: string[];
+    /**
+     * Transition Time (in seconds)
+     */
+    transitionTime: number;
+    /**
+     * Length of Time to display each background (in seconds)
+     */
+    viewTime: number;
+    /**
+     * Whether to reset the interval on init.
+     */
+    resetInterval: boolean;
+}
+
+/**
+ * This directive when applied to a div will hijack its background and apply a carousel of images.
+ */
+declare class BackgroundCarouselDirective implements OnDestroy {
+    /**
+     * Carousel Options
+     */
+    private _options;
+    /**
+     * Reference to the interval for swapping the background image.
+     */
+    private _interval;
+    /**
+     * Sets the options for the carousel
+     *
+     * @param value
+     */
+    set options(value: CarouselOptions);
+    /**
+     * Gets the options for the carousel
+     */
+    get options(): CarouselOptions;
+    /**
+     * Constructor will set up all of the behavior for the carousel based on the options supplied by the user.
+     *
+     * @param el
+     */
+    constructor();
+    /**
+     * Initializes the options to default settings for whatever isn't provided by the developer
+     */
+    private initOptions;
+    /**
+     * Clears the interval when the component is destroyed.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BackgroundCarouselDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BackgroundCarouselDirective, "[particleCarousel]", never, { "options": { "alias": "particleCarouselOptions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface AccordionText {
+    expand: string;
+    collapse: string;
+}
+interface CalendarText {
+    selectAYear: string;
+    selectAMonth: string;
+    january: string;
+    february: string;
+    march: string;
+    april: string;
+    may: string;
+    june: string;
+    july: string;
+    august: string;
+    september: string;
+    october: string;
+    november: string;
+    december: string;
+    sundayAbbr: string;
+    mondayAbbr: string;
+    tuesdayAbbr: string;
+    wednesdayAbbr: string;
+    thursdayAbbr: string;
+    fridayAbbr: string;
+    saturdayAbbr: string;
+    sunday: string;
+    monday: string;
+    tuesday: string;
+    wednesday: string;
+    thursday: string;
+    friday: string;
+    saturday: string;
+    select: string;
+    the: string;
+    resetDateToToday: string;
+    selectToday: string;
+    saveDate: string;
+    done: string;
+    minGreaterThenMax: string;
+}
+interface CheckboxText {
+    check: string;
+    uncheck: string;
+}
+interface ColorPickerText {
+    chooseColor: string;
+    enterHexCode: string;
+}
+interface DatePickerText {
+    calendarText?: CalendarText;
+    enterInFormat: string;
+    openCalendar: string;
+}
+interface DateRangePickerText {
+    calendarText?: CalendarText;
+    begin: string;
+    end: string;
+    done: string;
+    clear: string;
+    openCalendar: string;
+    selectRange: string;
+}
+interface DialogText {
+    close: string;
+    maximize: string;
+    minimize: string;
+}
+interface DropdownText {
+    placeholder: string;
+}
+interface IconSelectText {
+    selectAnIcon: string;
+    seeAllIcons: string;
+    fontAwesomeIcons: string;
+    filterBy: string;
+    all: string;
+    solid: string;
+    regular: string;
+    brands: string;
+    light: string;
+    customIcons: string;
+    previousPage: string;
+    nextPage: string;
+    searchIcons: string;
+    submitSearch: string;
+    clearResults: string;
+    couldntFindAnything: string;
+    modifySearchCriteria: string;
+    selection: string;
+    confirm: string;
+    select: string;
+    close: string;
+}
+interface IdleTimeoutText {
+    sessionExpiring: string;
+    second: string;
+    seconds: string;
+    stayLoggedIn: string;
+}
+interface LoaderText {
+    loadingText?: string;
+    loadingSubtext?: string;
+}
+interface MultiSelectText {
+    placeholder: string;
+    of: string;
+    optionsSelected: string;
+}
+interface NotificationText {
+    dismiss: string;
+}
+interface PaginatorText {
+    itemsPerPage: string;
+    choosePageSize: string;
+    previousPage: string;
+    nextPage: string;
+    disabled: string;
+    firstPage: string;
+    lastPage: string;
+    jumpToPage: string;
+    page: string;
+    outOf: string;
+    of: string;
+    results: string;
+}
+interface RichTextEditorText {
+    heading1: string;
+    heading2: string;
+    bold: string;
+    italic: string;
+    strike: string;
+    bulletedList: string;
+    orderedList: string;
+    leftAlign: string;
+    centerAlign: string;
+    rightAlign: string;
+    justifyAlign: string;
+    setLink: string;
+    removeLink: string;
+    clearFormat: string;
+    modifyLink: string;
+    addImage: string;
+    modifyImage: string;
+    cancel: string;
+    update: string;
+    url: string;
+}
+interface ScrollToTopText {
+    scrollToTop: string;
+}
+interface SlideoverText {
+    close: string;
+}
+interface SliderText {
+    selectAValue: string;
+    enterAValue: string;
+}
+interface WeekPickerText {
+    openCalendar: string;
+    selectWeek: string;
+    selectYear: string;
+    selectMonth: string;
+    january: string;
+    february: string;
+    march: string;
+    april: string;
+    may: string;
+    june: string;
+    july: string;
+    august: string;
+    september: string;
+    october: string;
+    november: string;
+    december: string;
+    sundayAbbr: string;
+    mondayAbbr: string;
+    tuesdayAbbr: string;
+    wednesdayAbbr: string;
+    thursdayAbbr: string;
+    fridayAbbr: string;
+    saturdayAbbr: string;
+    selectLastWeek: string;
+    lastWeek: string;
+    resetWeekSelection: string;
+    selectNextWeek: string;
+    nextWeek: string;
+}
+
+/**
+ * Particle Icon Select component provides a button and an icon picker that includes all of the Particle Icons as well as the FAS icons.
+ */
+declare class IconSelectComponent implements ControlValueAccessor, OnDestroy {
+    private service;
+    private changeDetectorRef;
+    /**
+     * The number of items to display per page
+     * @private
+     */
+    private static readonly PAGE_SIZE;
+    /**
+     * Set the value of the icon select
+     * @param value the value to set
+     */
+    set value(value: string);
+    get value(): string;
+    /**
+     * Set disabled
+     * @param disabled whether or not the icon picker should be disabled
+     */
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    /**
+     * Color class of the button
+     */
+    readonly buttonColorClass: _angular_core.InputSignal<string>;
+    /**
+     * The value to set to the button's width, min-width, height and min-height
+     */
+    readonly buttonSizing: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<IconSelectText>;
+    /**
+     * Icon select opened event emitter
+     */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Icon selected event emitter
+     */
+    readonly selected: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Dialog closed event emitter
+     */
+    readonly closed: _angular_core.OutputEmitterRef<any>;
+    /**
+     * The scrollable icon container
+     */
+    iconScrollContainer: ElementRef<HTMLDivElement>;
+    /**
+     * BehaviorSubject tracking the input value destructed into its prefix and class name
+     */
+    readonly _internalValue: BehaviorSubject<{
+        prefix: string;
+        name: string;
+    }>;
+    /**
+     * BehaviorSubject tracking the current filter value selection for icons
+     */
+    readonly _filter: BehaviorSubject<{
+        style: "all" | "solid" | "regular" | "brands";
+        type: "all" | "particle" | "fontawesome";
+    }>;
+    /**
+     * BehaviorSubject tracking the current icon search text value
+     */
+    readonly _searchText: BehaviorSubject<string>;
+    /**
+     * BehaviorSubject that emits when search button has been clicked
+     */
+    readonly _searchClick: BehaviorSubject<string>;
+    /**
+     * BehaviorSubject tracking the active pagination page
+     */
+    readonly _activePage: BehaviorSubject<number>;
+    /**
+     * Subject that emits on search input enter keyup
+     */
+    readonly _searchInputEnterKeyup: Subject<void>;
+    /**
+     * An array of all icons (as strings) that meet the current filter/search criteria as an Observable
+     * @private
+     */
+    private readonly icons$;
+    /**
+     * The count of total paginator pages as an Observable
+     */
+    readonly totalPages$: Observable<number>;
+    /**
+     * Observable boolean indicating whether or not the user can perform an icon text search
+     */
+    readonly canSearch$: Observable<boolean>;
+    /**
+     * Observable boolean indicating whether or not the user can paginate to the previous page
+     */
+    readonly canPaginatePrevious$: Observable<boolean>;
+    /**
+     * Observable boolean indicating whether or not the user can paginate to the next page
+     */
+    readonly canPaginateNext$: Observable<boolean>;
+    /**
+     * Paginated icons array as an Observable
+     */
+    readonly paginatedIcons$: Observable<Array<{
+        prefix: string;
+        name: string;
+    }>>;
+    /**
+     * Object that controls whether to show the dialog or not
+     */
+    showDialog: any;
+    /**
+     * Whether or not to show the icon selection preview
+     */
+    showIconSelectionPreview: boolean;
+    /**
+     * Subscription object to store search input enter keyup subscription
+     * @private
+     */
+    private readonly subscription;
+    /**
+     * The value of the icon select
+     * @private
+     */
+    private _value;
+    /**
+     * Whether or not the icon picker is disabled
+     * @private
+     */
+    private _disabled;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Dependency injection site
+     * @param service the IconsService
+     * @param changeDetectorRef the Angular ChangeDetectorRef
+     */
+    constructor();
+    /**
+     * Destroy component, unsubscribe from search input enter keyup subscription
+     */
+    ngOnDestroy(): void;
+    /**
+     * Write the input value
+     * @param value the value to write
+     */
+    writeValue(value: string): void;
+    /**
+     * Register onChange function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register onTouched function
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set disabled state
+     * @param isDisabled whether or not the icon picker should be disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Open the icon select dialog
+     */
+    openDialog(): void;
+    /**
+     * Close the icon select dialog
+     */
+    closeDialog(): void;
+    /**
+     * Handle filter select
+     * @param filter the selected filter
+     */
+    handleFilterSelect(filter: {
+        style: 'all' | 'solid' | 'regular' | 'brands';
+        type: 'all' | 'particle' | 'fontawesome';
+    }): void;
+    /**
+     * Update internal value on icon select
+     * @param icon the selected icon
+     */
+    handleIconSelect(icon: {
+        prefix: string;
+        name: string;
+    }): void;
+    /**
+     * Write value on confirm
+     */
+    handleIconSelectConfirm(): void;
+    /**
+     * Go to the next pagination page
+     */
+    paginateNext(): void;
+    /**
+     * Go to the previous pagination page
+     */
+    paginatePrevious(): void;
+    /**
+     * Clear search text and reset paginator
+     */
+    clearSearch(): void;
+    /**
+     * Update model
+     * @param value the new value of the model
+     * @private
+     */
+    private updateModel;
+    /**
+     * Reset filtering/pagination BehaviorSubject values
+     * @private
+     */
+    private reset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconSelectComponent, "particle-icon-select", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "buttonColorClass": { "alias": "buttonColorClass"; "required": false; "isSignal": true; }; "buttonSizing": { "alias": "buttonSizing"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "selected": "selected"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Representation of a pagination event
+ */
+interface PaginationEvent {
+    activePage: number;
+    pageSize: number;
+    totalLength: number;
+}
+
+/**
+ * A Particle paginator, because we hated the other ones on the market.
+ */
+declare class PaginatorComponent implements OnChanges, AfterViewInit {
+    private _pageSize;
+    /**
+     * An array of potential page sizes.
+     */
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    /**
+     * Current page size
+     */
+    set pageSize(pageSize: number);
+    get pageSize(): number;
+    /**
+     * Total number of items
+     */
+    readonly totalLength: _angular_core.InputSignal<number>;
+    readonly showPages: _angular_core.InputSignal<boolean>;
+    readonly showFirstLast: _angular_core.InputSignal<boolean>;
+    readonly showButtonLabels: _angular_core.InputSignal<boolean>;
+    readonly showResultsPanel: _angular_core.InputSignal<boolean>;
+    readonly startingPage: _angular_core.InputSignalWithTransform<any, number>;
+    readonly text: _angular_core.InputSignal<PaginatorText>;
+    /**
+     * Event Emitter for pagination or page size change.
+     */
+    readonly paginate: _angular_core.OutputEmitterRef<PaginationEvent>;
+    /**
+     * Currently active page
+     */
+    activePage: number;
+    /**
+     * For the page jump text input
+     */
+    pageJumpInput: string;
+    /**
+     * Number of pages
+     */
+    numberOfPages: number;
+    pageStartingValue: number;
+    pageEndingValue: number;
+    Math: Math;
+    /**
+     * Recalculate number of pages on input change
+     */
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    private resetPageStartEndValues;
+    /**
+     * Goes to the first page
+     */
+    goToFirst(): void;
+    /**
+     * Goes to the last page
+     */
+    goToLast(): void;
+    /**
+     * Calculates the number of pages
+     */
+    getNumberOfPages(): number;
+    private _goToPage;
+    /**
+     * Goes to a given page and emits a pagination event
+     *
+     * @param pageNumber
+     * @param inputFocus
+     */
+    goToPage(pageNumber: number, inputFocus?: boolean): void;
+    /**
+     * Goes to a given page, but does not emit a pagination event
+     * @param pageNumber
+     * @param inputFocus
+     */
+    setActivePage(pageNumber: number, inputFocus?: boolean): void;
+    /**
+     * Emits a pagination event with the current paginator data
+     */
+    emitEvent(): void;
+    /**
+     * Determines whether a given page exists or not.
+     *
+     * @param pageNumber
+     */
+    hasPage(pageNumber: number): boolean;
+    /**
+     * Gets the first value for a given page
+     *
+     * @param pageNumber
+     */
+    getStartingValueForPage(pageNumber: number): number;
+    /**
+     * Gets the last value for a given page
+     *
+     * @param pageNumber
+     */
+    getEndingValueForPage(pageNumber: number): number;
+    /**
+     * When a page size is changed, go back to the first page and emit a pagination event
+     */
+    pageSizeChange(): void;
+    /**
+     * Jump to a page based on user input
+     */
+    jumpPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "particle-paginator", never, { "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "totalLength": { "alias": "totalLength"; "required": false; "isSignal": true; }; "showPages": { "alias": "showPages"; "required": false; "isSignal": true; }; "showFirstLast": { "alias": "showFirstLast"; "required": false; "isSignal": true; }; "showButtonLabels": { "alias": "showButtonLabels"; "required": false; "isSignal": true; }; "showResultsPanel": { "alias": "showResultsPanel"; "required": false; "isSignal": true; }; "startingPage": { "alias": "startingPage"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "paginate": "paginate"; }, never, never, true, never>;
+}
+
+/**
+ * Profile Pic display shortcut
+ */
+declare class ProfilePicComponent {
+    /**
+     * Size of the profile pic circle (default to 50px)
+     */
+    size: string;
+    /**
+     * Configurable CSS Margin
+     */
+    margin: string;
+    /**
+     * Tooltip to explain what the picture is
+     */
+    toolTip: string;
+    /**
+     * Disable the tooltip
+     */
+    tooltipDisabled: boolean;
+    /**
+     * Use gravatar instead of a custom image
+     */
+    set gravatarEmail(gravatarEmail: string);
+    /**
+     * Image URL of the profile pic
+     */
+    set imageUrl(imageUrl: string);
+    url: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProfilePicComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProfilePicComponent, "particle-profile-pic", never, { "size": { "alias": "size"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "toolTip": { "alias": "toolTip"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gravatarEmail": { "alias": "gravatarEmail"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface RichTextCapabilities {
+    heading: boolean;
+    textDecoration: boolean;
+    list: boolean;
+    alignment: boolean;
+    link: boolean;
+    images: boolean;
+}
+
+declare const RICH_TEXT_VALUE_ACCESSOR: any;
+declare class RichTextComponent implements ControlValueAccessor, AfterViewInit {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly hideControls: _angular_core.InputSignal<boolean>;
+    readonly height: _angular_core.InputSignal<string>;
+    get readonly(): boolean;
+    set readonly(readonly: boolean);
+    readonly text: _angular_core.InputSignal<RichTextEditorText>;
+    readonly capabilities: _angular_core.InputSignal<RichTextCapabilities>;
+    readonly borderRadius: _angular_core.InputSignal<string>;
+    readonly textChanged: _angular_core.OutputEmitterRef<{
+        htmlValue: string;
+        textValue: string;
+    }>;
+    showDialog: any;
+    dialogLink: string;
+    dialogType: string;
+    /**
+     * Function called on change
+     */
+    onChange: ((value: string) => void) | undefined;
+    /**
+     * Function called on touch
+     */
+    onTouched: (() => void) | undefined;
+    private _value;
+    private _editable;
+    protected readonly window: Window & typeof globalThis;
+    private CustomLink;
+    editor: Editor;
+    get value(): any;
+    set value(value: string);
+    ngAfterViewInit(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    openLinkDialog(): void;
+    openImageDialog(): void;
+    changeEditorLink(action: string): void;
+    focus(position?: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextComponent, "particle-rich-text", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hideControls": { "alias": "hideControls"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "capabilities": { "alias": "capabilities"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; }, { "textChanged": "textChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Component to display a dialog with dynamic content
+ */
+declare class DialogComponent {
+    private dialogService;
+    /**
+     * Element reference to the dialog close button
+     */
+    closeButton: ElementRef<HTMLButtonElement>;
+    protected isMaximized: boolean;
+    /**
+     * Observable to update the effective width of the dialog on screen resize
+     */
+    effectiveWidth$: Observable<string>;
+    /**
+     * Object to operate whether the dialog is open/closed
+     */
+    private _object;
+    /**
+     * Object to operate whether the dialog is open/closed
+     */
+    set object(value: any);
+    get object(): any;
+    /**
+     * Title to show at the top of the dialog
+     */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * Class to apply to the title of the dialog
+     */
+    readonly titleClass: _angular_core.InputSignal<string>;
+    /**
+     * Show or hide the title bar
+     */
+    readonly showTitle: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to show close button and allow escape to close
+     */
+    readonly allowClose: _angular_core.InputSignal<boolean>;
+    /**
+     * Class to apply to the body of the dialog
+     */
+    readonly bodyClass: _angular_core.InputSignal<string>;
+    /**
+     * Height of the dialog (can use any height measurement)
+     */
+    readonly height: _angular_core.InputSignal<string>;
+    /**
+     * Width of the dialog (can use any width measurement)
+     */
+    readonly width: _angular_core.InputSignal<string>;
+    readonly borderRadius: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<DialogText>;
+    /**
+     * Event Emitter for when the dialog is closed
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitted when dialog has finished opening
+     */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    toggleMaximize(): void;
+    /**
+     * Null the object to close the dialog, emit the close event.
+     */
+    close(): void;
+    /**
+     * Emit closed/opened events based on state when dialog animation ends
+     * @param event
+     */
+    onAnimationDone(event: AnimationEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogComponent, "particle-dialog", never, { "object": { "alias": "object"; "required": false; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleClass": { "alias": "titleClass"; "required": false; "isSignal": true; }; "showTitle": { "alias": "showTitle"; "required": false; "isSignal": true; }; "allowClose": { "alias": "allowClose"; "required": false; "isSignal": true; }; "bodyClass": { "alias": "bodyClass"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "opened": "opened"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Component to display a popover with custom content
+ */
+declare class PopoverComponent implements OnDestroy {
+    private renderer;
+    protected readonly window: Window & typeof globalThis;
+    /**
+     * The offset of the popover from its target (in pixels)
+     */
+    readonly offset: _angular_core.InputSignal<number>;
+    /**
+     * Set the width of the popover in pixels (defaults to auto)
+     */
+    set width(width: string);
+    get width(): string;
+    /**
+     * Set the height of the popover in pixels (defaults to auto)
+     */
+    set height(height: string);
+    get height(): string;
+    /**
+     * A class-list to apply to the popover content
+     */
+    readonly classList: _angular_core.InputSignal<string>;
+    readonly targetOverride: _angular_core.InputSignal<EventTarget>;
+    readonly openDirection: _angular_core.InputSignal<"above" | "below">;
+    readonly alignment: _angular_core.InputSignal<"left" | "center">;
+    readonly scaleForMobile: _angular_core.InputSignal<string>;
+    /**
+     * Event emitted on popover open
+     */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitted on popover close
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Whether the popover should render
+     */
+    render: boolean;
+    /**
+     * Whether the popover is visible
+     */
+    visible: boolean;
+    /**
+     * The width of the popover
+     */
+    private _width;
+    /**
+     * The height of the popover
+     */
+    private _height;
+    /**
+     * The element to target
+     * @private
+     */
+    private target;
+    /**
+     * The popover content container
+     * @private
+     */
+    private container;
+    /**
+     * Array of escape keyup unlisten functions
+     * @private
+     */
+    private escapeKeyUpUnlisteners;
+    /**
+     * Destroy component, clean up event listeners
+     */
+    ngOnDestroy(): void;
+    /**
+     * Close popover on click
+     * @param event the click MouseEvent
+     */
+    onClick(event: MouseEvent): void;
+    /**
+     * Re-position popover on window resize
+     */
+    onWindowResize(): void;
+    /**
+     * Toggle the popover from open to closed or closed to open
+     * @param event the event whose target element will act as
+     *              the popover target. If an event is not provided,
+     *              the popover will close
+     */
+    toggle(event?: Event): void;
+    /**
+     * Handle animation start
+     * @param event the AnimationEvent
+     */
+    onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Handle animation end
+     * @param event the AnimationEvent
+     */
+    onAnimationDone(event: AnimationEvent): void;
+    /**
+     * Open the popover
+     * @private
+     */
+    private open;
+    /**
+     * Close the popover
+     */
+    close(): void;
+    /**
+     * Position the popover
+     * @private
+     */
+    private positionPopover;
+    /**
+     * Add escape keyup listeners to all focusable elements to close
+     * the popover
+     * @private
+     */
+    private addEventListeners;
+    /**
+     * Get all focusable child elements of the input node
+     * @param node the node to query for focusable children
+     * @param elements the found focusable elements
+     * @private
+     */
+    private getFocusableElements;
+    /**
+     * Invoke escape keyup unlisten functions
+     * @private
+     */
+    private removeEventListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "particle-popover", never, { "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "classList": { "alias": "classList"; "required": false; "isSignal": true; }; "targetOverride": { "alias": "targetOverride"; "required": false; "isSignal": true; }; "openDirection": { "alias": "openDirection"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "scaleForMobile": { "alias": "scaleForMobile"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Component to allow a user to input/select a date
+ */
+declare class DatePickerComponent implements ControlValueAccessor, OnDestroy, OnInit {
+    private renderer;
+    private changeDetectorRef;
+    /**
+     * Allowed keys for date input
+     */
+    private static readonly ALLOWED_KEYS;
+    /**
+     * Matches YYYY-MM-DD
+     * @private
+     */
+    private static readonly BROWSER_DATE_PICKER_FORMAT;
+    /**
+     * Matches MM/DD/YYYY
+     * @private
+     */
+    private static readonly FULL_DATE_FORMAT;
+    /**
+     * Matches M/D/YYYY
+     * @private
+     */
+    private static readonly SHORT_DATE_FORMAT;
+    /**
+     * Matches M/DD/YYYY
+     * @private
+     */
+    private static readonly SHORT_MONTH_DATE_FORMAT;
+    /**
+     * Matches MM/D/YYYY
+     * @private
+     */
+    private static readonly SHORT_DAY_DATE_FORMAT;
+    /**
+     * A reference date with all fields set to 0
+     * @private
+     */
+    private static readonly referenceDate;
+    /**
+     * Value input setter
+     */
+    set value(value: Date);
+    /**
+     * Value getter
+     */
+    get value(): Date;
+    set disabled(disabled: boolean);
+    /**
+     * Disabled getter
+     */
+    get disabled(): boolean;
+    set dateRange(dateRange: {
+        minDate: Date;
+        maxDate: Date;
+    });
+    /**
+     * The ID to set on the input
+     */
+    readonly inputId: _angular_core.InputSignal<string>;
+    /**
+     * Value to use as the date picker input's aria label
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Optional class-list to add to the date picker input
+     */
+    readonly inputClassList: _angular_core.InputSignal<any>;
+    /**
+     * Optional class-list to add to the calendar button
+     */
+    readonly calendarButtonClassList: _angular_core.InputSignal<string>;
+    /**
+     * Close the picker when a selection is made
+     */
+    readonly closeOnSelect: _angular_core.InputSignal<boolean>;
+    /**
+     * Placeholder override
+     */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly inputOnly: _angular_core.InputSignal<boolean>;
+    private _text;
+    set text(text: DatePickerText);
+    get text(): DatePickerText;
+    /**
+     * Event emitted on date picker input
+     */
+    readonly input: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Event emitted on valid date selection/input
+     */
+    readonly dateSelected: _angular_core.OutputEmitterRef<Date>;
+    /**
+     * ViewChild of the date picker div
+     */
+    datePickerDiv: ElementRef<HTMLDivElement>;
+    /**
+     * ViewChild of the calendar div
+     */
+    calendarDiv: ElementRef<HTMLDivElement>;
+    calendarPopover: PopoverComponent;
+    /**
+     * The current date
+     */
+    private readonly currentDate;
+    /**
+     * The fixed height of the calendar widget
+     */
+    private readonly calendarHeight;
+    /**
+     * The fixed width of the calendar widget
+     */
+    private readonly calendarWidth;
+    /**
+     * The amount of padding to apply between the date picker input and the calendar widget
+     */
+    private readonly calendarPadding;
+    /**
+     * String tracking date picker input
+     */
+    dateString: string;
+    mobileDateString: string;
+    /**
+     * Whether to show the calendar
+     */
+    showCalendar: {
+        currentValue: Date;
+    };
+    /**
+     * In mobile (screen width is less than 768), swap to a native input
+     */
+    isMobile: boolean;
+    /**
+     * The valid selection interval
+     * @private
+     */
+    validSelectionInterval: {
+        start: Date;
+        end: Date;
+    };
+    /**
+     * The internal control accessor value
+     * @private
+     */
+    private _value;
+    /**
+     * The internal disabled state
+     * @private
+     */
+    private _disabled;
+    /**
+     * Window resize unlisten function
+     */
+    private resizeListener;
+    /**
+     * Parse the input Date value into a string
+     * @param value the value to parse
+     * @private
+     */
+    private static parseDate;
+    /**
+     * Parse the input date string into a Date
+     * @param dateString the string to parse
+     * @private
+     */
+    private static parseDateString;
+    /**
+     * Get the date format that matches the input date string, null if no match
+     * @param dateString the string to test
+     * @private
+     */
+    private static getDateFormat;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    onWindowResize(event: any): void;
+    /**
+     * Init component, set up window resize listener
+     */
+    ngOnInit(): void;
+    /**
+     * Destroy component, invoke window resize unlisten function
+     */
+    ngOnDestroy(): void;
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: Date): void;
+    /**
+     * Register control value accessor change function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Register touch handler
+     * @param fn the touch handler to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state
+     * @param isDisabled whether or not the component should be disabled
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * Only allow input from digits, forward slashes, and navigation keys
+     */
+    filterInput(event: KeyboardEvent): void;
+    /**
+     * Clear value if no input, write parsed date if input requirements fulfilled
+     */
+    handleBlur(): void;
+    /**
+     * Write on input if valid date within interval
+     */
+    handleInput(): void;
+    handleMobileInput(): void;
+    setMobileValue(): void;
+    /**
+     * Update the model value
+     * @param value the value to update the model to
+     */
+    updateModel(value: Date): void;
+    /**
+     * Open the calendar widget
+     * @param event the click MouseEvent
+     */
+    openCalendar(event?: MouseEvent): void;
+    /**
+     * Hide calendar overlay and remove calendar from the DOM
+     */
+    handleCalendarClose(): void;
+    /**
+     * Calculate and set the calendar's position based on the screen height.
+     * Positioning prefers to open at the bottom, if not enough room on bottom,
+     * positioning is attempted at the top, otherwise it attempts to vertically
+     * center
+     */
+    private setCalendarPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "particle-date-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "inputClassList": { "alias": "inputClassList"; "required": false; "isSignal": true; }; "calendarButtonClassList": { "alias": "calendarButtonClassList"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputOnly": { "alias": "inputOnly"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; }; }, { "input": "input"; "dateSelected": "dateSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Interface representing a date interval
+ */
+declare interface Interval {
+    start: Date | number;
+    end: Date | number;
+}
+/**
+ * Interface representing a Date broken down by date/month/year
+ * with extended metadata
+ */
+declare interface MetaDate$1 {
+    /**
+     * The day of the week (starting at 0)
+     */
+    day: number;
+    /**
+     * The day of the month (starting at 1)
+     */
+    date: number;
+    /**
+     * The month (starting at 0)
+     */
+    month: number;
+    /**
+     * The full year
+     */
+    year: number;
+    /**
+     * Whether the day is selectable
+     */
+    selectable: boolean;
+}
+/**
+ * Component that allows a user to select a date from a calendar
+ */
+declare class CalendarComponent implements OnDestroy, OnInit {
+    /**
+     * The keyboard arrow keys
+     * @private
+     */
+    private static readonly ARROW_KEYS;
+    /**
+     * ViewChild of the calendar widget parent div element
+     */
+    calendarWidgetDiv: ElementRef<HTMLDivElement>;
+    /**
+     * ViewChild of the month select element
+     */
+    yearSelect: ElementRef<HTMLSelectElement>;
+    /**
+     * ViewChild of the done button
+     */
+    doneButton: ElementRef<HTMLButtonElement>;
+    /**
+     * QueryList of the calendar date buttons for the currently selected month/year
+     */
+    calendarDates: QueryList<ElementRef<HTMLButtonElement>>;
+    /**
+     * The selected date value
+     */
+    set value(value: Date);
+    /**
+     * The range of available dates to choose from
+     */
+    set dateRange(dateRange: {
+        minDate: Date;
+        maxDate: Date;
+    });
+    set text(text: CalendarText);
+    get text(): CalendarText;
+    readonly showControls: _angular_core.InputSignal<boolean>;
+    private _text;
+    /**
+     * Event emitted on date select
+     */
+    readonly selected: _angular_core.OutputEmitterRef<Date>;
+    /**
+     * Event emitted on close (either through the button, escape keyup or click off of widget).
+     * Note: it is the parent component's job to actually hide the calendar, this event
+     *       acts as a signal that that action should be taken
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * The current Date broken down by day/month/year
+     */
+    readonly currentDate: MetaDate$1;
+    /**
+     * Array of days of the week
+     */
+    weekDays: string[];
+    /**
+     * BehaviorSubject tracking the current value
+     */
+    readonly _value: BehaviorSubject<MetaDate$1>;
+    /**
+     * BehaviorSubject tracking the valid selection interval
+     */
+    readonly _validSelectionInterval: BehaviorSubject<Interval>;
+    /**
+     * BehaviorSubject tracking the currently selected month
+     */
+    readonly _selectedMonth: BehaviorSubject<number>;
+    /**
+     * BehaviorSubject tracking the currently selected year
+     */
+    readonly _selectedYear: BehaviorSubject<number>;
+    /**
+     * The full month for the current selected month/year
+     */
+    readonly fullMonth$: Observable<Array<MetaDate$1>>;
+    /**
+     * The range of selectable years as an Observable
+     */
+    readonly validYearRange$: Observable<Array<number>>;
+    /**
+     * Subscription for the combination of value and valid selection interval
+     * @private
+     */
+    private readonly subscription;
+    /**
+     * The currently selected date
+     */
+    selectedDate: MetaDate$1 | null;
+    /**
+     * Generate a 42 element array representing the input month's days with
+     * padding from the previous/following month
+     * @param month the month to generate dates for
+     * @param year the year to generate the month for
+     * @param selectionInterval the selection interval
+     */
+    private static generateMonth;
+    /**
+     * Generate an Array of numbers representing the span of years between the input
+     * @param minYear the start of the range
+     * @param maxYear the end of the range
+     * @param currentYear the current year
+     */
+    private static generateYearRange;
+    constructor();
+    /**
+     * Init component
+     */
+    ngOnInit(): void;
+    /**
+     * Destroy component, unsubscribe from any active subscriptions
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle window keyup events
+     * @param event the keyup KeyboardEvent
+     */
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * Emit closed event on click if clicked outside calendar widget
+     * @param event the click MouseEvent
+     */
+    handleClick(event: MouseEvent): void;
+    /**
+     * Update selected date and emit selection event
+     * @param selectedDate the selected date
+     */
+    handleDateSelection(selectedDate: MetaDate$1): void;
+    /**
+     * Select the current date and toggle selected month/year to match
+     */
+    selectToday(): void;
+    /**
+     * Handle arrow key navigation for calendar date buttons
+     * @param key the pressed arrow key
+     * @private
+     */
+    private onArrowKeyUp;
+    /**
+     * Attempt to focus on date indexed immediately to the left of the input date
+     * @param date the day of the month
+     * @private
+     */
+    private navigateLeft;
+    /**
+     * Attempt to focus on date indexed immediately to the right of the input date
+     * @param date the day of the month
+     * @private
+     */
+    private navigateRight;
+    /**
+     * Attempt to navigate one week in the past from the input date
+     * @param date the day of the month
+     * @private
+     */
+    private navigateUp;
+    /**
+     * Attempt to navigate one week in the future from the input date
+     * @param date the day of the month
+     * @private
+     */
+    private navigateDown;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "particle-calendar", never, { "value": { "alias": "value"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; "text": { "alias": "text"; "required": false; }; "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class DateRangePickerComponent implements ControlValueAccessor, AfterViewInit {
+    private changeDetectorRef;
+    currentYear: number;
+    _disabled: boolean;
+    private _value$;
+    private _lastValue;
+    private _init;
+    valueObs$: rxjs.Observable<any>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly inputClassList: _angular_core.InputSignal<string>;
+    readonly calendarButtonClassList: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<DateRangePickerText>;
+    set dateRange(value: {
+        minDate: Date;
+        maxDate: Date;
+    });
+    get dateRange(): {
+        minDate: Date;
+        maxDate: Date;
+    };
+    get endDateRange(): {
+        minDate: Date;
+        maxDate: Date;
+    };
+    private _dateRange;
+    private _endDateRange;
+    set value(value: {
+        start: Date;
+        end: Date;
+    });
+    get value(): {
+        start: Date;
+        end: Date;
+    };
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Format for the selected date range in the selection preview. Must
+     * be a valid Angular DatePipe format
+     */
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    calendarPopover: PopoverComponent;
+    beginCalendar: CalendarComponent;
+    endCalendar: CalendarComponent;
+    ngAfterViewInit(): void;
+    get beginDate(): Date;
+    set beginDate(beginDate: Date);
+    get endDate(): Date;
+    set endDate(endDate: Date);
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: {
+        start: Date;
+        end: Date;
+    }): void;
+    /**
+     * Register function on change
+     * @param fn the function to change
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register function on touch
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set disabled state
+     * @param isDisabled whether or not the control is disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    openCalendar(event: Event): void;
+    updateModel(isBegin: boolean, date: Date): void;
+    checkState(): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePickerComponent, "particle-date-range-picker", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "inputClassList": { "alias": "inputClassList"; "required": false; "isSignal": true; }; "calendarButtonClassList": { "alias": "calendarButtonClassList"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "dateRange": { "alias": "dateRange"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Interface representing a dropdown option
+ */
+interface DropdownOption {
+    type?: 'option';
+    /**
+     * The value of the dropdown option
+     */
+    value: string | number;
+    /**
+     * The label of the dropdown option
+     */
+    label: string;
+    /**
+     * Whether or not the option is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Data context object containing properties to fill
+     * dropdown option template placeholders
+     */
+    dataContext?: {
+        [key: string]: unknown;
+    };
+}
+
+/**
+ * Interface representing an array of dropdown options
+ * grouped under a label
+ */
+interface DropdownOptionGroup {
+    type?: 'group';
+    /**
+     * The option group label
+     */
+    groupLabel: string;
+    /**
+     * The group options
+     */
+    options: Array<DropdownOption>;
+}
+
+/**
+ * Type representing the dropdown component option input
+ */
+declare type DropdownOptionInput = Array<DropdownOption | DropdownOptionGroup>;
+/**
+ * Dropdown component
+ */
+declare class DropdownComponent implements ControlValueAccessor {
+    private renderer;
+    private changeDetectorRef;
+    /**
+     * Set the value of the dropdown
+     * @param value the value to set
+     */
+    set value(value: string | number);
+    get value(): string | number;
+    /**
+     * The dropdown options/option groups
+     */
+    set options(options: DropdownOptionInput);
+    /**
+     * Dependency injection site
+     * @param renderer the Angular renderer
+     * @param changeDetectorRef reference to the Angular change detector
+     */
+    constructor();
+    /**
+     * The amount of offset (in pixels) to place between the dropdown
+     * and its list overlay
+     * @private
+     */
+    private static readonly DROPDOWN_LIST_OFFSET;
+    /**
+     * List of arrow key keycodes
+     * @private
+     */
+    private static readonly ARROW_KEYS;
+    /**
+     * ViewChild of the dropdown
+     */
+    dropdown: ElementRef<HTMLDivElement>;
+    /**
+     * ViewChild of the dropdown button
+     */
+    dropdownButton: ElementRef<HTMLButtonElement>;
+    /**
+     * ViewChild of the dropdown list
+     */
+    dropdownList: ElementRef<HTMLDivElement>;
+    /**
+     * QueryList of dropdown option ViewChildren
+     */
+    dropdownOptions: QueryList<ElementRef<HTMLButtonElement>>;
+    /**
+     * ContentChild of the dropdown option template
+     */
+    template: TemplateRef<HTMLElement>;
+    /**
+     * Whether the dropdown should be disabled
+     */
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly text: _angular_core.InputSignal<DropdownText>;
+    /**
+     * Class list to assign to the dropdown
+     */
+    readonly classList: _angular_core.InputSignal<string>;
+    readonly buttonClassList: _angular_core.InputSignal<string>;
+    readonly collapsedButtonTemplate: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly collapsedButtonTooltipEnabled: _angular_core.InputSignal<boolean>;
+    readonly dropdownBoxMinWidth: _angular_core.InputSignal<number>;
+    /**
+     * Event emitted on value change, emits the new value
+     */
+    readonly changed: _angular_core.OutputEmitterRef<string | number>;
+    /**
+     * BehaviorSubject tracking the input dropdown options/option groups
+     */
+    readonly _options: BehaviorSubject<DropdownOptionInput>;
+    /**
+     * Full list of all active options, whether they are in a group or not
+     * @private
+     */
+    private _allOptions;
+    /**
+     * Typeahead string while users are typing into the input field
+     * @private
+     */
+    private _fullPredictiveTextString;
+    /**
+     * Timeout to clear the _fullPredictiveTextString after a user stops typing for a certain amount of time
+     * @private
+     */
+    private _timeout;
+    /**
+     * BehaviorSubject tracking the current value of the dropdown
+     */
+    readonly _internalValue: BehaviorSubject<string | number>;
+    /**
+     * Observable map of option value (stringified if a number) to data context
+     */
+    private readonly dataContextMap$;
+    /**
+     * The data context of the selected option as an Observable
+     */
+    readonly selectedDataContext$: Observable<Record<string, unknown>>;
+    tooltipData$: Observable<unknown>;
+    private static getAllOptions;
+    /**
+     * Unique ID to assign to the dropdown
+     */
+    readonly dropdownId: any;
+    /**
+     * Whether the dropdown should be rendered
+     */
+    render: boolean;
+    /**
+     * Whether the dropdown is open
+     */
+    opened: boolean;
+    /**
+     * The index of the focused option in the dropdown list
+     */
+    selectionIndex: number;
+    /**
+     * In mobile (screen width is less than 768), swap to a native input
+     */
+    isMobile: boolean;
+    /**
+     * The current value of the dropdown
+     * @private
+     */
+    private _value;
+    /**
+     * Removes options that do not have both a label and a value,
+     * also removes empty groups (or groups that have no valid options)
+     * @param options the options to sanitize
+     * @private
+     */
+    private static sanitizeOptionInput;
+    /**
+     * Add option label to data context if not present. If $implicit
+     * value is not present, it will be added with the label as its value.
+     * If $implicit is already present, it will add a label key to the context
+     * @param label the option label
+     * @param dataContext the option data context
+     * @private
+     */
+    private static addLabelToDataContext;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: string | number): void;
+    /**
+     * Register function on change
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register function on touch
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state
+     * @param isDisabled disabled or not
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * Reposition and resize the dropdown on window resize
+     */
+    onWindowResize(event: any): void;
+    /**
+     * Prevent default behavior for arrow key keydown event
+     * @param event the keydown KeyboardEvent
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Close the dropdown list on tab and handle arrow key navigation
+     * @param event the keyup KeyboardEvent
+     */
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * Close the dropdown list (if opened) on click if outside the list
+     * @param event the click MouseEvent
+     */
+    onClick(event: MouseEvent): void;
+    /**
+     * Close dropdown on escape keyup and focus on dropdown button
+     * @param event the keyup KeyboardEvent
+     */
+    onEscapeKeyUp(event: Event): void;
+    /**
+     * Set focus to dropdown option on mouse enter and update selected index
+     * @param option the dropdown option to focus
+     * @param index the index of the option to focus
+     */
+    onDropdownOptionMouseEnter(option: HTMLButtonElement, index: number): void;
+    /**
+     * Set focus to dropdown option on mouse move and update selected index
+     * @param option the dropdown option to focus
+     * @param index the index of the option to focus
+     */
+    onDropdownOptionMouseMove(option: HTMLButtonElement, index: number): void;
+    /**
+     * Write value and close dropdown on option select
+     * @param value the value to write
+     * @param disabled whether or not the selected option is disabled
+     */
+    onDropdownOptionSelect(value: string | number, disabled: boolean): void;
+    /**
+     * Open the dropdown list and align it
+     * @param event the click MouseEvent
+     */
+    openDropdown(event: MouseEvent): void;
+    /**
+     * Close the dropdown list
+     */
+    closeDropdown(): void;
+    /**
+     * Position and resize dropdown list on animation start if toState is open
+     * @param event the Angular AnimationEvent
+     */
+    onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Stop rendering dropdown list on animation done if toState is close
+     * @param event the Angular AnimationEvent
+     */
+    onAnimationDone(event: AnimationEvent): void;
+    /**
+     * Focus on the selected dropdown option on dropdown open
+     * @private
+     */
+    setSelectionIndex(): void;
+    /**
+     * Update internal value and emit change events if input value differs from current value
+     * @param value the selected value
+     * @private
+     */
+    private handleDropdownOptionSelect;
+    onModelChangeMobile(value: any): void;
+    /**
+     * Align the dropdown list with the dropdown
+     * @private
+     */
+    private positionDropdownList;
+    /**
+     * Match the dropdown list width to the dropdown's width
+     * @private
+     */
+    private resizeDropdownList;
+    /**
+     * Handle arrow keyup event
+     * @param key the arrow key
+     */
+    private onArrowKeyUp;
+    /**
+     * Get the next enabled dropdown option (relative to the current selection index).
+     * If the currently selected option is the final available option, it is
+     * returned. If no selection has been made, the first available option is returned
+     * @private
+     */
+    private getNextOption;
+    /**
+     * Get the previous enabled dropdown option (relative to the current selection index).
+     * If the currently selected option is the first available option, it is
+     * returned
+     * @private
+     */
+    private getPreviousOption;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "particle-dropdown", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "classList": { "alias": "classList"; "required": false; "isSignal": true; }; "buttonClassList": { "alias": "buttonClassList"; "required": false; "isSignal": true; }; "collapsedButtonTemplate": { "alias": "collapsedButtonTemplate"; "required": false; "isSignal": true; }; "collapsedButtonTooltipEnabled": { "alias": "collapsedButtonTooltipEnabled"; "required": false; "isSignal": true; }; "dropdownBoxMinWidth": { "alias": "dropdownBoxMinWidth"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "changed": "changed"; }, ["template"], ["template"], true, never>;
+}
+
+/**
+ * Interface representing a multi-select option
+ */
+interface MultiSelectOption {
+    type?: 'option';
+    /**
+     * The value of the multi-select option
+     */
+    value: string | number;
+    /**
+     * The label of the multi-select option
+     */
+    label: string;
+    /**
+     * Whether or not the option is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Data context object containing properties to fill
+     * multi-select option template placeholders
+     */
+    dataContext?: {
+        [key: string]: unknown;
+    };
+}
+
+/**
+ * Interface representing an array of multi-select options
+ * grouped under a label
+ */
+interface MultiSelectOptionGroup {
+    type?: 'group';
+    /**
+     * The option group label
+     */
+    groupLabel: string;
+    /**
+     * The group options
+     */
+    options: Array<MultiSelectOption>;
+}
+
+/**
+ * Type representing the multi-select component option input
+ */
+declare type MultiSelectOptionInput = Array<MultiSelectOption | MultiSelectOptionGroup>;
+/**
+ * Multi-select component
+ */
+declare class MultiSelectComponent implements ControlValueAccessor {
+    private renderer;
+    private changeDetectorRef;
+    /**
+     * Set the value of the multi-select
+     * @param value the value to set
+     */
+    set value(value: Array<string | number>);
+    get value(): Array<any>;
+    /**
+     * The multi-select options/option groups
+     */
+    set options(options: MultiSelectOptionInput);
+    /**
+     * The amount of offset (in pixels) to place between the multi-select
+     * and its list overlay
+     * @private
+     */
+    private static readonly LIST_OFFSET;
+    /**
+     * List of arrow key keycodes
+     * @private
+     */
+    private static readonly ARROW_KEYS;
+    /**
+     * ViewChild of the multi-select
+     */
+    multiSelect: ElementRef<HTMLDivElement>;
+    /**
+     * ViewChild of the multi-select button
+     */
+    multiSelectButton: ElementRef<HTMLButtonElement>;
+    /**
+     * ViewChild of the multi-select list
+     */
+    multiSelectList: ElementRef<HTMLDivElement>;
+    /**
+     * QueryList of multi-select option ViewChildren
+     */
+    multiSelectOptions: QueryList<ElementRef<HTMLButtonElement>>;
+    /**
+     * ContentChild of the multi-select option template
+     */
+    template: TemplateRef<HTMLElement>;
+    /**
+     * Whether the multi-select should be disabled
+     */
+    disabled: _angular_core.ModelSignal<boolean>;
+    /**
+     * Class list to assign to the multi-select
+     */
+    readonly classList: _angular_core.InputSignal<string>;
+    readonly buttonClassList: _angular_core.InputSignal<string>;
+    readonly entryClassList: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<MultiSelectText>;
+    /**
+     * Style of the multi-select
+     */
+    readonly type: _angular_core.InputSignal<"input" | "expanded">;
+    readonly maxExpandedEntries: _angular_core.InputSignal<number>;
+    readonly expandedAsGrid: _angular_core.InputSignal<boolean>;
+    readonly collapsedButtonTemplate: _angular_core.InputSignal<TemplateRef<any>>;
+    /**
+     * Event emitted on value change, emits the new value
+     */
+    readonly changed: _angular_core.OutputEmitterRef<(string | number)[]>;
+    /**
+     * BehaviorSubject tracking the input multi-select options/option groups
+     */
+    readonly _options: BehaviorSubject<MultiSelectOptionInput>;
+    /**
+     * BehaviorSubject tracking the current value of the multi-select
+     */
+    readonly _internalValue: BehaviorSubject<(string | number)[]>;
+    /**
+     * Observable map of option value (stringified if a number) to data context
+     */
+    readonly dataContextMap$: Observable<Record<string, Record<string, unknown>>>;
+    /**
+     * Observable map of stringified option value to boolean indicating the user's selections
+     */
+    readonly selectionValueMap$: Observable<Record<string, boolean>>;
+    /**
+     * The count of selected options as an Observable
+     */
+    readonly selectionCount$: Observable<number>;
+    /**
+     * Unique ID to assign to the multiSelect
+     */
+    readonly multiSelectId: any;
+    /**
+     * Whether to render the multi-select list
+     */
+    render: boolean;
+    /**
+     * Whether the multi-select is open
+     */
+    opened: boolean;
+    /**
+     * The index of the focused option in the multiSelect list
+     */
+    selectionIndex: number;
+    optionCount: number;
+    /**
+     * The current value of the multiSelect
+     * @private
+     */
+    private _value;
+    /**
+     * Removes options that do not have both a label and a value,
+     * also removes empty groups (or groups that have no valid options)
+     * @param options the options to sanitize
+     * @private
+     */
+    private static sanitizeOptionInput;
+    /**
+     * Add option label to data context if not present. If $implicit
+     * value is not present, it will be added with the label as its value.
+     * If $implicit is already present, it will add a label key to the context
+     * @param label the option label
+     * @param dataContext the option data context
+     * @private
+     */
+    private static addLabelToDataContext;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Dependency injection site
+     * @param renderer the Angular renderer
+     * @param changeDetectorRef reference to the Angular change detector
+     */
+    constructor();
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: Array<string | number>): void;
+    /**
+     * Register function on change
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register function on touch
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state
+     * @param isDisabled disabled or not
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * Reposition and resize the multiSelect on window resize
+     */
+    onWindowResize(): void;
+    /**
+     * Prevent default behavior for arrow key keydown event
+     * @param event the keydown KeyboardEvent
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Close the multi-select list on tab and handle arrow key navigation
+     * @param event the keyup KeyboardEvent
+     */
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * Close the multi-select list (if opened) on click if outside the list
+     * @param event the click MouseEvent
+     */
+    onClick(event: MouseEvent): void;
+    /**
+     * Close multi-select on escape keyup and focus on multi-select button
+     * @param event the keyup KeyboardEvent
+     */
+    onEscapeKeyUp(event: Event): void;
+    /**
+     * Set focus to multi-select option on mouse enter and update selected index
+     * @param option the multiSelect option to focus
+     * @param index the index of the option to focus
+     */
+    onMultiSelectOptionMouseEnter(option: HTMLButtonElement, index: number): void;
+    /**
+     * Set focus to multi-select option on mouse move and update selected index
+     * @param option the multiSelect option to focus
+     * @param index the index of the option to focus
+     */
+    onMultiSelectOptionMouseMove(option: HTMLButtonElement, index: number): void;
+    /**
+     * Write value and close multi-select on option select
+     * @param value the value to write
+     * @param disabled whether or not the selected option is disabled
+     */
+    onMultiSelectOptionSelect(value: string | number, disabled: boolean): void;
+    /**
+     * Open the multi-select list and align it
+     * @param event the click MouseEvent
+     */
+    openMultiSelect(event: MouseEvent): void;
+    /**
+     * Close the multiSelect list
+     */
+    closeMultiSelect(): void;
+    /**
+     * Position and resize the multi-select list on animation start if toState is open
+     * @param event the Angular AnimationEvent
+     */
+    onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Stop rendering the multi-select list on animation done if toState is close
+     * @param event the Angular AnimationEvent
+     */
+    onAnimationDone(event: AnimationEvent): void;
+    /**
+     * If the input value is already in the value array, remove it. Otherwise add it
+     * @param value the selected value
+     * @private
+     */
+    private handleMultiSelectOptionSelect;
+    /**
+     * Align the multi-select list with the multiSelect
+     * @private
+     */
+    private positionMultiSelectList;
+    /**
+     * Match the multi-select list width to the multi-select's width
+     * @private
+     */
+    private resizeMultiSelectList;
+    /**
+     * Handle arrow keyup event
+     * @param key the arrow key
+     */
+    private onArrowKeyUp;
+    /**
+     * Get the next enabled multi-select option (relative to the current selection index).
+     * If the currently selected option is the final available option, it is
+     * returned. If no selection has been made, the first available option is returned
+     * @private
+     */
+    private getNextOption;
+    /**
+     * Get the previous enabled multi-select option (relative to the current selection index).
+     * If the currently selected option is the first available option, it is
+     * returned
+     * @private
+     */
+    private getPreviousOption;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelectComponent, "particle-multi-select", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "classList": { "alias": "classList"; "required": false; "isSignal": true; }; "buttonClassList": { "alias": "buttonClassList"; "required": false; "isSignal": true; }; "entryClassList": { "alias": "entryClassList"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "maxExpandedEntries": { "alias": "maxExpandedEntries"; "required": false; "isSignal": true; }; "expandedAsGrid": { "alias": "expandedAsGrid"; "required": false; "isSignal": true; }; "collapsedButtonTemplate": { "alias": "collapsedButtonTemplate"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "changed": "changed"; }, ["template"], ["template"], true, never>;
+}
+
+/**
+ * Component for displaying notifications
+ */
+declare class NotificationComponent {
+    private notificationService;
+    readonly text: _angular_core.InputSignal<NotificationText>;
+    /**
+     * Array of notifications as an Observable
+     */
+    readonly notifications$: rxjs.Observable<_entake_particle.Notification[]>;
+    /**
+     * Map of notification severity to color class
+     */
+    readonly severityColorMap: {
+        success: string;
+        warn: string;
+        error: string;
+        info: string;
+    };
+    /**
+     * Map of notification severity to icon class
+     */
+    readonly severityIconMap: {
+        success: string;
+        warn: string;
+        error: string;
+        info: string;
+    };
+    /**
+     * Delete a notification
+     * @param id the ID of the notification to delete
+     */
+    deleteNotification(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationComponent, "particle-notification", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Interface representing a Date broken down by day/date/week/month/year
+ * with extended metadata
+ */
+declare interface MetaDate {
+    /**
+     * The day of the week (starting at 0)
+     */
+    day: number;
+    /**
+     * The day of the month (starting at 1)
+     */
+    date: number;
+    /**
+     * The week of the year
+     */
+    week: number;
+    /**
+     * The month (starting at 0)
+     */
+    month: number;
+    /**
+     * The full year
+     */
+    year: number;
+    /**
+     * Whether the day is selectable
+     */
+    selectable: boolean;
+}
+/**
+ * Interface representing a week of the year with metadata
+ */
+declare interface MetaWeek {
+    /**
+     * The week of the year (starting at 1)
+     */
+    week: number;
+    /**
+     * The year of the week
+     */
+    year: number;
+    /**
+     * Whether the week can be selected in the week picker
+     */
+    selectable: boolean;
+    /**
+     * The numeric dates of the days in the week
+     */
+    dates: Array<number>;
+}
+/**
+ * Component to allow a user to select a week
+ */
+declare class WeekPickerComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    /**
+     * Set the value of the week picker
+     * @param value the value to set
+     */
+    set value(value: {
+        start: Date;
+        end: Date;
+    });
+    /**
+     * Get the value of the week picker
+     */
+    get value(): {
+        start: Date;
+        end: Date;
+    };
+    /**
+     * Get whether the control is disabled
+     */
+    get disabled(): boolean;
+    /**
+     * Set disabled
+     */
+    set disabled(disabled: boolean);
+    /**
+     * Set the valid date boundary for the week picker
+     * @param dateRange
+     */
+    set dateRange(dateRange: {
+        start?: Date;
+        end?: Date;
+    });
+    /**
+     * Class list to apply to the date range input
+     */
+    readonly inputClassList: _angular_core.InputSignal<any>;
+    /**
+     * Class list to apply to the week picker button
+     */
+    readonly calendarButtonClassList: _angular_core.InputSignal<string>;
+    /**
+     * The aria label to apply to the date range input
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Format for the selected date range in the selection preview. Must
+     * be a valid Angular DatePipe format
+     */
+    readonly dateFormat: _angular_core.InputSignal<string>;
+    /**
+     * Close the picker when a selection is made
+     */
+    readonly closeOnSelect: _angular_core.InputSignal<boolean>;
+    readonly text: _angular_core.InputSignal<WeekPickerText>;
+    /**
+     * Event emitted on week select
+     */
+    readonly weekSelected: _angular_core.OutputEmitterRef<{
+        start: Date;
+        end: Date;
+    }>;
+    /**
+     * ViewChild of the calendar popover
+     */
+    calendarPopover: PopoverComponent;
+    /**
+     * The current date
+     */
+    readonly currentDate: MetaDate;
+    /**
+     * BehaviorSubject tracking the value of the week picker
+     */
+    readonly _internalValue: BehaviorSubject<{
+        start: Date;
+        end: Date;
+    }>;
+    /**
+     * BehaviorSubject tracking the selectable date range
+     */
+    readonly _validSelectionInterval: BehaviorSubject<{
+        start: Date;
+        end: Date;
+    }>;
+    /**
+     * BehaviorSubject tracking the currently selected month
+     */
+    readonly _selectedMonth: BehaviorSubject<number>;
+    /**
+     * BehaviorSubject tracking the currently selected year
+     */
+    readonly _selectedYear: BehaviorSubject<number>;
+    /**
+     * The selected week of the year of the start of the selection as an Observable
+     */
+    readonly selectedWeek$: Observable<number>;
+    /**
+     * The year of the start of the selected week as an Observable
+     */
+    readonly selectedYear$: Observable<number>;
+    /**
+     * Observable boolean representing if next week (relative to the current selection) is selectable
+     */
+    readonly canSelectNextWeek$: Observable<boolean>;
+    /**
+     * Observable boolean representing if last week (relative to the current selection) is selectable
+     */
+    readonly canSelectLastWeek$: Observable<boolean>;
+    /**
+     * The range of selectable years as an Observable
+     */
+    readonly validYearRange$: Observable<Array<number>>;
+    /**
+     * An array of MetaWeeks representing a month as an Observable
+     */
+    readonly fullMonth$: Observable<Array<MetaWeek>>;
+    /**
+     * The value of the week picker
+     * @private
+     */
+    private _value;
+    /**
+     * Whether the control is disabled
+     * @private
+     */
+    private _disabled;
+    /**
+     * Generate an Array of numbers representing the span of years between the input
+     * @param minYear the start of the range
+     * @param maxYear the end of the range
+     * @param currentYear the current year
+     */
+    private static generateYearRange;
+    /**
+     * Generate a month with week and selectable status metadata
+     * @param month the month to generate
+     * @param year the year of the month to generate
+     * @param selectionInterval the interval representing the
+     *                              minimum to the maximum week of the year
+     * @private
+     */
+    private static generateMonth;
+    /**
+     * Get the input date as a MetaDate
+     * @param date the date to transform
+     * @param selectable whether or not the date is selectable
+     * @private
+     */
+    private static getMetaDate;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Dependency injection site
+     * @param changeDetectorRef the Angular ChangeDetectorRef
+     */
+    constructor();
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: {
+        start: Date;
+        end: Date;
+    }): void;
+    /**
+     * Register function on change
+     * @param fn the function to change
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register function on touch
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set disabled state
+     * @param isDisabled whether or not the control is disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Open the week picker popover
+     * @param event the event to pass to the popover
+     */
+    openCalendar(event: Event): void;
+    /**
+     * Handle week select
+     * @param week the week of the year
+     * @param selectable whether or not the week is selectable
+     */
+    onWeekSelect(week: number, selectable: boolean): void;
+    /**
+     * Select next week (relative to the week of the current selection)
+     */
+    selectNextWeek(): void;
+    /**
+     * Select last week (relative to the week of the current selection)
+     */
+    selectLastWeek(): void;
+    /**
+     * Select the current week
+     */
+    selectCurrentWeek(): void;
+    /**
+     * Update model
+     * @param value the new value of the model
+     * @private
+     */
+    private updateModel;
+    /**
+     * Set the selection interval
+     * @param interval the input selection interval
+     * @private
+     */
+    private setSelectionInterval;
+    /**
+     * Set the selectable status of the current date
+     * @private
+     */
+    private setCurrentDateSelectable;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeekPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeekPickerComponent, "particle-week-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; "inputClassList": { "alias": "inputClassList"; "required": false; "isSignal": true; }; "calendarButtonClassList": { "alias": "calendarButtonClassList"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "weekSelected": "weekSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Component that wraps the native HTML5 color picker for supported browsers
+ */
+declare class ColorPickerComponent implements ControlValueAccessor, OnInit {
+    private renderer;
+    private changeDetectorRef;
+    /**
+     * Regex to match a hexadecimal string (000000)
+     * @private
+     */
+    private static readonly FULL_HEX_REGEX;
+    /**
+     * Regex to match a short hexadecimal string (000)
+     * @private
+     */
+    private static readonly SHORT_HEX_REGEX;
+    /**
+     * Regex to match a valid hex character (A-F, a-f, 0-9)
+     * @private
+     */
+    private static readonly HEX_CHARACTER_REGEX;
+    /**
+     * Navigation keys
+     * @private
+     */
+    private static readonly NAVIGATION_KEYS;
+    /**
+     * Set the value of the color picker
+     * @param value the value to set
+     */
+    set value(value: string);
+    /**
+     * Set disabled
+     * @param disabled whether or not the control should be disabled
+     */
+    set disabled(disabled: boolean);
+    /**
+     * Class list to apply to the hex string input
+     */
+    classList: string;
+    text: ColorPickerText;
+    /**
+     * Event emitted on hex string input event. Emits the current value of the input
+     */
+    input: EventEmitter<string>;
+    /**
+     * Event emitted on color selection from color picker (color picker widget dismissed)
+     * or valid hex string typed in input. Emits the current value of the input
+     */
+    colorSelected: EventEmitter<string>;
+    /**
+     * ViewChild of the color input element
+     */
+    colorInput: ElementRef<HTMLInputElement>;
+    /**
+     * Whether to render the component
+     */
+    render: boolean;
+    /**
+     * Whether the native HTML5 color picker is supported
+     */
+    colorPickerSupported: boolean;
+    /**
+     * The value of the color picker
+     */
+    _value: string;
+    /**
+     * Whether the color picker is disabled
+     * @private
+     */
+    _disabled: boolean;
+    /**
+     * Expand a short hex string (#abc) into its full form (#aabbcc)
+     * @param hexString the short hex string to expand
+     * @private
+     */
+    private static expandShortHexString;
+    /**
+     * Function to call on change
+     */
+    onChange: (value: any) => void;
+    /**
+     * Function to call on touch
+     */
+    onTouched: () => any;
+    /**
+     * Init component, check for color picker browser support
+     */
+    ngOnInit(): void;
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: string): void;
+    /**
+     * Register on change function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register on touched function
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set whether the control should be disabled
+     * @param isDisabled disabled or not
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Prevent illegal input
+     * @param event the keydown KeyboardEvent
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Update model
+     * @param value the new value of the model
+     * @param emitColorSelected whether or not emit the color selected event
+     * @private
+     */
+    updateModel(value: string, emitColorSelected?: boolean): void;
+    /**
+     * Null out value on blur if not valid hex string, otherwise update model
+     * @param value the value to check
+     */
+    handleBlur(value: string): void;
+    /**
+     * Prevent pasting a non-hex string
+     * @param event the paste ClipboardEvent
+     */
+    handlePaste(event: ClipboardEvent): void;
+    /**
+     * Determine if the browser supports the HTML5 color picker
+     * @private
+     */
+    private isColorPickerSupported;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "particle-color-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "classList": { "alias": "classList"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "input": "input"; "colorSelected": "colorSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Component that wraps the native HTML5 slider
+ */
+declare class SliderComponent implements ControlValueAccessor, OnInit {
+    private changeDetectorRef;
+    /**
+     * ViewChild of the slider input
+     */
+    sliderInput: ElementRef<HTMLInputElement>;
+    /**
+     * Set the value of the component
+     * @param value the value to set
+     */
+    set value(value: number);
+    get value(): number;
+    /**
+     * Set the minimum slider value
+     * @param min the value to set
+     */
+    set min(min: number);
+    /**
+     * Set the maximum slider value
+     * @param max the value to set
+     */
+    set max(max: number);
+    /**
+     * Set the slider step size
+     * @param step the value to set
+     */
+    set step(step: number);
+    /**
+     * Set the disabled state of the slider/input
+     * @param disabled the value to set
+     */
+    set disabled(disabled: boolean);
+    /**
+     * Set the input class list
+     * @param inputClassList the value to set
+     */
+    set inputClassList(inputClassList: string);
+    /**
+     * The unit being represented by the slider
+     */
+    readonly unit: _angular_core.InputSignal<string>;
+    /**
+     * The aria-label to append to the slider/input
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<SliderText>;
+    /**
+     * Event emitted on slider/slider input input event
+     */
+    readonly input: _angular_core.OutputEmitterRef<number>;
+    /**
+     * The internal value of the component
+     */
+    _value: number;
+    /**
+     * The minimum slider value
+     */
+    _min: number;
+    /**
+     * The maximum slider value
+     */
+    _max: number;
+    /**
+     * The step size of the slider
+     */
+    _step: number;
+    /**
+     * Whether the slider is disabled or not
+     */
+    _disabled: boolean;
+    /**
+     * The class list to apply to the number input
+     */
+    _inputClassList: string;
+    /**
+     * The width of the colored section of the slider bar
+     */
+    sliderWidth: number;
+    onChange: (value: any) => void;
+    onTouched: () => any;
+    /**
+     * Init component
+     */
+    ngOnInit(): void;
+    /**
+     * Set internal value when external value changes
+     * @param value the external value
+     */
+    writeValue(value: number): void;
+    /**
+     * Register onChange function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register onTouched function
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state of the component
+     * @param isDisabled disabled or not
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * Update value on input
+     * @param value the new value of the component
+     */
+    handleInput(value: number): void;
+    /**
+     * Prevent the paste event from completing
+     * @param event the paste ClipboardEvent
+     */
+    preventPaste(event: ClipboardEvent): void;
+    /**
+     * Set the slider width
+     * @private
+     */
+    private setSliderWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "particle-slider", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputClassList": { "alias": "inputClassList"; "required": false; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "input": "input"; }, never, never, true, never>;
+}
+
+declare class AccordionComponent implements AfterContentInit, AfterViewInit {
+    expanded: Set<number>;
+    multiple: boolean;
+    height: string;
+    headerClass: string;
+    textClass: string;
+    iconCollapsed: string;
+    iconExpanded: string;
+    showIcon: boolean;
+    text: AccordionText;
+    items: QueryList<AccordionItemDirective>;
+    contentDivs: QueryList<any>;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * @param index - index of the accordion item
+     */
+    getToggleState: (index: number) => any;
+    toggleState: (index: number) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "particle-accordion", never, { "multiple": { "alias": "multiple"; "required": false; }; "height": { "alias": "height"; "required": false; }; "headerClass": { "alias": "headerClass"; "required": false; }; "textClass": { "alias": "textClass"; "required": false; }; "iconCollapsed": { "alias": "iconCollapsed"; "required": false; }; "iconExpanded": { "alias": "iconExpanded"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, ["items"], never, true, never>;
+}
+
+declare class SlideoverComponent implements AfterViewInit, OnDestroy {
+    private _position;
+    slideoverOpen: boolean;
+    visible: boolean;
+    set position(position: string);
+    get position(): string;
+    readonly modal: _angular_core.InputSignal<boolean>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly bgClass: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<SlideoverText>;
+    /**
+     * Breakpoint that will make the container take over the screen when it's crossed.
+     */
+    readonly breakpoint: _angular_core.InputSignal<number>;
+    readonly hideCloseButton: _angular_core.InputSignal<boolean>;
+    readonly opened: _angular_core.OutputEmitterRef<any>;
+    readonly closed: _angular_core.OutputEmitterRef<any>;
+    overlay: ElementRef;
+    breakpointExceeded: boolean;
+    onResize(event: any): void;
+    private _determineBreakpointExceeded;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    private addModalMask;
+    private removeModalMask;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideoverComponent, "particle-slideover", never, { "position": { "alias": "position"; "required": false; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "bgClass": { "alias": "bgClass"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "hideCloseButton": { "alias": "hideCloseButton"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class IdleTimer {
+    private interval;
+    private timeoutTracker;
+    private readonly eventHandler;
+    private readonly timeout;
+    private readonly onTimeout;
+    constructor(timeout: number, onTimeout: any);
+    private startInterval;
+    private updateExpiredTime;
+    private tracker;
+    cleanUp(): void;
+    resetTimer(): void;
+    isTimerExpired(): boolean;
+}
+
+declare class IdleTimeoutComponent implements OnInit {
+    borderRadius: string;
+    timeoutInSeconds: number;
+    text: IdleTimeoutText;
+    timerEnd: EventEmitter<any>;
+    /**
+     * Timeout Dialog - shows when the inactivity timer has 1 minute left, giving the user the ability to confirm they're still active.
+     */
+    timeoutDialog: DialogComponent;
+    /**
+     * Used for the countdown to user auto-logout
+     */
+    count: number;
+    /**
+     * Controls showing the dialog
+     */
+    showDialog: any;
+    idleTimer: IdleTimer;
+    private readonly COUNTDOWN_LENGTH;
+    private finalCountdown;
+    private timerReset;
+    ngOnInit(): void;
+    openDialog(): void;
+    private setupFinalCountdown;
+    private handleTimerEnd;
+    resetTimer(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdleTimeoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdleTimeoutComponent, "particle-idle-timeout", never, { "borderRadius": { "alias": "borderRadius"; "required": false; }; "timeoutInSeconds": { "alias": "timeoutInSeconds"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "timerEnd": "timerEnd"; }, never, never, true, never>;
+}
+
+declare class ScrollToTopComponent implements OnDestroy, AfterViewInit {
+    renderer: Renderer2;
+    readonly content: _angular_core.InputSignal<HTMLElement>;
+    readonly scrollDistance: _angular_core.InputSignal<number>;
+    readonly bottomOffset: _angular_core.InputSignal<number>;
+    readonly text: _angular_core.InputSignal<ScrollToTopText>;
+    $scrollTop: BehaviorSubject<number>;
+    private _listener;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    scrollToTop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollToTopComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollToTopComponent, "particle-scroll-to-top", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "scrollDistance": { "alias": "scrollDistance"; "required": false; "isSignal": true; }; "bottomOffset": { "alias": "bottomOffset"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LayoutFullwidthSidebarComponent {
+    readonly mainContent: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly rightSidebar: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly mainContentContainerClassList: _angular_core.InputSignal<string>;
+    readonly rightSidebarContainerClassList: _angular_core.InputSignal<string>;
+    readonly rightSidebarSticky: _angular_core.InputSignal<boolean>;
+    readonly headerHeight: _angular_core.InputSignal<string>;
+    readonly footerHeight: _angular_core.InputSignal<string>;
+    readonly rightSidebarWidth: _angular_core.InputSignal<string>;
+    readonly breakpoint: _angular_core.InputSignal<number>;
+    readonly rightSidebarCollapsedTabOffset: _angular_core.InputSignal<number>;
+    readonly collapsedClassList: _angular_core.InputSignal<string>;
+    readonly mobileSidebarEnabled: _angular_core.InputSignal<boolean>;
+    slideover: SlideoverComponent;
+    onResize(event: any): void;
+    protected readonly window: Window & typeof globalThis;
+    get stickySidebarHeight(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutFullwidthSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutFullwidthSidebarComponent, "particle-layout-fullwidth-sidebar", never, { "mainContent": { "alias": "mainContent"; "required": false; "isSignal": true; }; "rightSidebar": { "alias": "rightSidebar"; "required": false; "isSignal": true; }; "mainContentContainerClassList": { "alias": "mainContentContainerClassList"; "required": false; "isSignal": true; }; "rightSidebarContainerClassList": { "alias": "rightSidebarContainerClassList"; "required": false; "isSignal": true; }; "rightSidebarSticky": { "alias": "rightSidebarSticky"; "required": false; "isSignal": true; }; "headerHeight": { "alias": "headerHeight"; "required": false; "isSignal": true; }; "footerHeight": { "alias": "footerHeight"; "required": false; "isSignal": true; }; "rightSidebarWidth": { "alias": "rightSidebarWidth"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "rightSidebarCollapsedTabOffset": { "alias": "rightSidebarCollapsedTabOffset"; "required": false; "isSignal": true; }; "collapsedClassList": { "alias": "collapsedClassList"; "required": false; "isSignal": true; }; "mobileSidebarEnabled": { "alias": "mobileSidebarEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LayoutFullFramingComponent {
+    readonly mainContent: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly rightSidebar: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly header: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly footer: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly mainContentContainerClassList: _angular_core.InputSignal<string>;
+    readonly rightSidebarContainerClassList: _angular_core.InputSignal<string>;
+    readonly headerClassList: _angular_core.InputSignal<string>;
+    readonly footerClassList: _angular_core.InputSignal<string>;
+    readonly headerHeight: _angular_core.InputSignal<string>;
+    readonly footerHeight: _angular_core.InputSignal<string>;
+    readonly rightSidebarWidth: _angular_core.InputSignal<string>;
+    readonly breakpoint: _angular_core.InputSignal<number>;
+    readonly rightSidebarCollapsedTabOffset: _angular_core.InputSignal<number>;
+    readonly collapsedClassList: _angular_core.InputSignal<string>;
+    readonly mobileSidebarEnabled: _angular_core.InputSignal<boolean>;
+    slideover: SlideoverComponent;
+    onResize(event: any): void;
+    protected readonly window: Window & typeof globalThis;
+    get stickySidebarHeight(): string;
+    get contentSidebarHeight(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutFullFramingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutFullFramingComponent, "particle-layout-full-framing", never, { "mainContent": { "alias": "mainContent"; "required": false; "isSignal": true; }; "rightSidebar": { "alias": "rightSidebar"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "footer": { "alias": "footer"; "required": false; "isSignal": true; }; "mainContentContainerClassList": { "alias": "mainContentContainerClassList"; "required": false; "isSignal": true; }; "rightSidebarContainerClassList": { "alias": "rightSidebarContainerClassList"; "required": false; "isSignal": true; }; "headerClassList": { "alias": "headerClassList"; "required": false; "isSignal": true; }; "footerClassList": { "alias": "footerClassList"; "required": false; "isSignal": true; }; "headerHeight": { "alias": "headerHeight"; "required": false; "isSignal": true; }; "footerHeight": { "alias": "footerHeight"; "required": false; "isSignal": true; }; "rightSidebarWidth": { "alias": "rightSidebarWidth"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "rightSidebarCollapsedTabOffset": { "alias": "rightSidebarCollapsedTabOffset"; "required": false; "isSignal": true; }; "collapsedClassList": { "alias": "collapsedClassList"; "required": false; "isSignal": true; }; "mobileSidebarEnabled": { "alias": "mobileSidebarEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ToggleOptions {
+    affirmativeColorClass?: string;
+    affirmativeLabel?: string;
+    affirmativeIcon?: string;
+    negativeColorClass?: string;
+    negativeLabel?: string;
+    negativeIcon?: string;
+    accessibilityLabel?: string;
+    toggleSwitchWidth: number;
+    toggleTrackWidth: number;
+}
+
+declare class ToggleSwitchComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    private _options$;
+    options$: rxjs.Observable<ToggleOptions>;
+    set options(options: ToggleOptions);
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly changed: _angular_core.OutputEmitterRef<boolean>;
+    private _value;
+    get value(): boolean;
+    set value(value: boolean);
+    /**
+     * Function called on change
+     */
+    onChange: ((value: boolean) => void) | undefined;
+    /**
+     * Function called on touch
+     */
+    onTouched: (() => void) | undefined;
+    handleClick(): void;
+    /**
+     * Register function on change
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register function on touch
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state
+     * @param isDisabled disabled or not
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    writeValue(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleSwitchComponent, "particle-toggle-switch", never, { "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+declare class CheckboxComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    _value: boolean;
+    private _disabled;
+    onChange: (value: any) => void;
+    onTouched: () => any;
+    set disabled(disabled: boolean);
+    get disabled(): boolean;
+    set value(value: string | boolean);
+    get value(): string | boolean;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<CheckboxText>;
+    type: string;
+    /**
+     * Write value
+     * @param value the value to write
+     */
+    writeValue(value: string): void;
+    /**
+     * Register control value accessor change function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Register touch handler
+     * @param fn the touch handler to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state
+     * @param isDisabled whether or not the component should be disabled
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    click(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "particle-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const INPUTMASK_VALUE_ACCESSOR: any;
+declare class InputMaskComponent implements OnInit, ControlValueAccessor {
+    type: string;
+    slotChar: string;
+    autoClear: boolean;
+    style: any;
+    inputId: string;
+    styleClass: string;
+    placeholder: string;
+    size: number;
+    maxlength: number;
+    tabindex: string;
+    ariaLabel: string;
+    ariaRequired: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    unmask: boolean;
+    name: string;
+    required: boolean;
+    characterPattern: string;
+    autoFocus: boolean;
+    autocomplete: string;
+    inputViewChild: ElementRef;
+    onComplete: EventEmitter<any>;
+    onFocus: EventEmitter<any>;
+    onBlur: EventEmitter<any>;
+    onInput: EventEmitter<any>;
+    value: any;
+    _mask: string;
+    input: HTMLInputElement;
+    filled: boolean;
+    defs: any;
+    tests: any[];
+    partialPosition: any;
+    firstNonMaskPos: number;
+    lastRequiredNonMaskPos: any;
+    len: number;
+    oldVal: string;
+    buffer: any;
+    defaultBuffer: string;
+    focusText: string;
+    caretTimeoutId: any;
+    androidChrome: boolean;
+    focused: boolean;
+    onModelChange: (val?: any) => void;
+    onModelTouched: (val?: any) => void;
+    ngOnInit(): void;
+    get mask(): string;
+    set mask(val: string);
+    initMask(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(val: boolean): void;
+    caret(first?: number, last?: number): any;
+    isCompleted(): boolean;
+    getPlaceholder(i: number): string;
+    seekNext(pos: number): number;
+    seekPrev(pos: number): number;
+    shiftL(begin: number, end: number): void;
+    shiftR(pos: number): void;
+    handleAndroidInput(e: Event): void;
+    onInputBlur(e: Event): void;
+    onKeyDown(e: KeyboardEvent): void;
+    onKeyPress(e: KeyboardEvent): void;
+    /**
+     * Adjust cursor position if clicked on empty space ahead of the existing input
+     */
+    onClick(): void;
+    clearBuffer(start: number, end: number): void;
+    writeBuffer(): void;
+    checkVal(allow?: boolean): number;
+    onInputFocus(event: Event): void;
+    onInputChange(event: Event): void;
+    handleInputChange(event: Event): void;
+    getUnmaskedValue(): string;
+    updateModel(e: any): void;
+    updateFilledState(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputMaskComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputMaskComponent, "particle-input-mask", never, { "type": { "alias": "type"; "required": false; }; "slotChar": { "alias": "slotChar"; "required": false; }; "autoClear": { "alias": "autoClear"; "required": false; }; "style": { "alias": "style"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "size": { "alias": "size"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRequired": { "alias": "ariaRequired"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "unmask": { "alias": "unmask"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "characterPattern": { "alias": "characterPattern"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; }, { "onComplete": "onComplete"; "onFocus": "onFocus"; "onBlur": "onBlur"; "onInput": "onInput"; }, never, never, true, never>;
+}
+
+declare class ProgressBarComponent {
+    private _percentComplete;
+    set percentComplete(percentComplete: number);
+    get percentComplete(): number;
+    readonly backgroundColorClass: _angular_core.InputSignal<string>;
+    readonly progressColorClass: _angular_core.InputSignal<string>;
+    readonly showPercentComplete: _angular_core.InputSignal<boolean>;
+    readonly borderRadius: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly showBorder: _angular_core.InputSignal<boolean>;
+    readonly showMovement: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "particle-progress-bar", never, { "percentComplete": { "alias": "percentComplete"; "required": false; }; "backgroundColorClass": { "alias": "backgroundColorClass"; "required": false; "isSignal": true; }; "progressColorClass": { "alias": "progressColorClass"; "required": false; "isSignal": true; }; "showPercentComplete": { "alias": "showPercentComplete"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showBorder": { "alias": "showBorder"; "required": false; "isSignal": true; }; "showMovement": { "alias": "showMovement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LoaderComponent {
+    text: LoaderText;
+    disableText: boolean;
+    protected backgroundStyle: string | undefined;
+    private _colors;
+    set colors(colors: Array<string>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "particle-loader", never, { "text": { "alias": "text"; "required": false; }; "disableText": { "alias": "disableText"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RadioButtonsComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly options: _angular_core.InputSignal<DropdownOption[]>;
+    readonly colorClass: _angular_core.InputSignal<string>;
+    readonly isDisplayColumn: _angular_core.InputSignal<boolean>;
+    onChange: (value: any) => void;
+    onTouched: () => any;
+    /**
+     * Set internal value when external value changes
+     * @param value the external value
+     */
+    writeValue(value: string): void;
+    /**
+     * Register onChange function
+     * @param fn the function to register
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Register onTouched function
+     * @param fn the function to register
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Set the disabled state of the component
+     * @param isDisabled disabled or not
+     */
+    setDisabledState?(isDisabled: boolean): void;
+    handleInput(value: string | number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButtonsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioButtonsComponent, "particle-radio-buttons", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "colorClass": { "alias": "colorClass"; "required": false; "isSignal": true; }; "isDisplayColumn": { "alias": "isDisplayColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * This interceptor will force the Content-Type header to application/json so that each http call doesn't have to.
+ */
+declare class JsonInterceptor implements HttpInterceptor {
+    /**
+     * Intercept method to set the content type header.
+     *
+     * @param req
+     * @param next
+     */
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JsonInterceptor, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<JsonInterceptor>;
+}
+
+/**
+ * This class provides some foundational REST endpoint call capabilities. It will do things like unpack lists into native objects and
+ * return Observables so that you don't have to deal with mapping each and every response. It'll also log errors to the console and pass
+ * along the error text for you.
+ */
+declare class BaseDataService {
+    protected http: HttpClient;
+    /**
+     * Extensions of this class can provide the Base URL so that they don't need to write out the full URL for every call made.
+     */
+    protected getBaseUrl(): string;
+    /**
+     * If you receive a 404 from an endpoint, you can choose to treat it like a successful empty response
+     * by overriding this and returning true.
+     *
+     * @protected
+     */
+    protected ignoreNoResultsError(): boolean;
+    /**
+     * Takes an HTTPClient object so that it can make REST calls.
+     *
+     * @param http
+     */
+    constructor(http: HttpClient);
+    /**
+     * Gets a result from an endpoint. Executes an HTTP GET.
+     *
+     * @param url
+     * @param params
+     */
+    handleGet(url: string, params?: HttpParams): Observable<any>;
+    /**
+     * Will get a single result from an endpoint. Executes an HTTP GET.
+     *
+     * @param url
+     */
+    handleGetOne(url: string): Observable<any>;
+    /**
+     * Gets a List of Values. Will unpack the data object automatically. Executes an HTTP GET.
+     *
+     * @param url
+     */
+    handleGetList(url: string): Observable<any>;
+    /**
+     * Gets a file from an ednpoint. Executes an HTTP GET.
+     *
+     * @param url
+     * @param params
+     */
+    handleFileGet(url: string, params?: HttpParams): Observable<any>;
+    /**
+     * The handleFileGet will use this to get a file.
+     *
+     * @param url
+     * @param isFileResponse
+     * @param params
+     */
+    private handleGetDetailed;
+    /**
+     * Posts data to an endpoint. HTTP POST.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePost(url: string, payload: any): Observable<any>;
+    /**
+     * Posts data to an endpoint with an expected return of a File.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePostWithFileResponse(url: string, payload: any): Observable<any>;
+    /**
+     * The handlePost methods will use this to make Post calls easier.
+     *
+     * @param url
+     * @param payload
+     * @param isJson
+     * @param isFileResponse
+     */
+    private handlePostDetailed;
+    /**
+     * Update data with a REST call. HTTP PUT.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePut(url: string, payload: any): Observable<any>;
+    /**
+     * Used by the handlePut method to make it simpler and the guts more reusable.
+     *
+     * @param url
+     * @param payload
+     * @param isJson
+     */
+    private handlePutDetailed;
+    /**
+     * Executes an HTTP DELETE to remove data.
+     *
+     * @param url
+     */
+    handleDelete(url: string): Observable<any>;
+    /**
+     * Handles an Observable error
+     *
+     * @param error
+     */
+    handleObservableError(error: HttpErrorResponse): Observable<any>;
+    /**
+     * Logs an error and rethrows it
+     *
+     * @param error
+     * @param ignoreNoResultsError
+     */
+    handleError(error: HttpErrorResponse, ignoreNoResultsError: boolean, noResultsResponse?: any): Observable<any>;
+    /**
+     * Performs a deep copy of a JS object.
+     *
+     * @param o
+     */
+    deepCopy<T>(o: T): T;
+    /**
+     * Gets the expected response type from an endpoint
+     *
+     * @param isFileResponse
+     */
+    private getOptions;
+}
+
+/**
+ * Wrapper around interactions with Local Storage. Handles serializing things to JSON to make it easier to push more complex data into
+ * local storage.
+ */
+declare class LocalStorageService {
+    /**
+     * Retrieve an object from LocalStorage
+     *
+     * @param key
+     */
+    getObject<T>(key: string): T | null;
+    /**
+     * Get straight text out of local storage. Don't use this if the data is a JSON Object.
+     *
+     * @param key
+     */
+    getText(key: string): string;
+    /**
+     * Puts an object into Local Storage. Handles stringifying the JS Object.
+     *
+     * @param key
+     * @param object
+     */
+    putObject(key: string, object: any): void;
+    /**
+     * Puts text into Local Storage.
+     *
+     * @param key
+     * @param value
+     */
+    putText(key: string, value: string): void;
+    /**
+     * Removes an item from local storage based on the key.
+     *
+     * @param key
+     */
+    remove(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LocalStorageService>;
+}
+
+declare class DialogService {
+    dialogs: DialogComponent[];
+    private escapeListener;
+    registerDialog(dialog: DialogComponent): void;
+    unregisterDialog(dialog: DialogComponent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogService>;
+}
+
+/**
+ * Model representing a notification
+ */
+interface Notification {
+    /**
+     * The notification ID
+     */
+    id?: string;
+    /**
+     * The notification severity
+     */
+    severity: 'success' | 'info' | 'warn' | 'error';
+    /**
+     * The notification summary
+     */
+    summary: string;
+    /**
+     * The notification detail
+     */
+    detail?: string;
+}
+
+/**
+ * Service for adding/deleting notifications
+ */
+declare class NotificationService {
+    /**
+     * Valid characters that a notification ID can be composed from
+     * @private
+     */
+    private static readonly ID_CHARACTERS;
+    /**
+     * BehaviorSubject tracking an array of active notifications
+     * @private
+     */
+    private readonly _notifications;
+    /**
+     * The number of milliseconds before an added notification automatically removes itself.
+     * Defaults to 3000 milliseconds
+     * @private
+     */
+    private notificationLife;
+    /**
+     * Generate a random ID
+     * @private
+     */
+    private static generateId;
+    /**
+     * Add a notification
+     * @param notification the notification to add
+     */
+    add(notification: Notification): void;
+    /**
+     * Delete a notification
+     * @param id the ID of the notification to delete
+     */
+    deleteNotification(id: string): void;
+    /**
+     * Get notifications as an Observable
+     */
+    getNotifications(): Observable<Array<Notification>>;
+    /**
+     * Set the number of milliseconds before added notifications disappear
+     * @param milliseconds the number of milliseconds to set
+     */
+    setNotificationLife(milliseconds: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare const Z_INDEX_LAYERS: {
+    BASE: string;
+    FRAME: string;
+    OVERLAY: string;
+    DIALOG: string;
+    NOTIFICATION: string;
+};
+interface Theme {
+    themeId: string;
+    isDefault: boolean;
+    name: string;
+    layoutColors: ThemeLayoutColors;
+    layoutVariables: ThemeLayoutVariables;
+    stylingVariables: ThemeStylingVariables;
+    colorPalette: ThemeColorPalette;
+    buttonColorPalette: ThemeButtonColorPalette;
+    fonts: Array<ThemeFont>;
+    accessibility: ThemeAccessibility;
+    zIndexList?: Array<string>;
+}
+interface ThemeLayoutColors {
+    menuColor: string;
+    headerColor: string;
+    footerColor: string;
+    bodyColor: string;
+    contentColor: string;
+}
+interface ThemeColorPalette {
+    bgRed: string;
+    bgOrange: string;
+    bgYellow: string;
+    bgGreen: string;
+    bgBlue: string;
+    bgPurple: string;
+    bgBrown: string;
+    bgGrey: string;
+    extension: Array<ThemeColorPaletteExtension>;
+}
+interface ThemeButtonColorPalette {
+    okButtonColor: string;
+    cancelButtonColor: string;
+    deleteButtonColor: string;
+    saveButtonColor: string;
+    nextButtonColor: string;
+    previousButtonColor: string;
+    openButtonColor: string;
+    closeButtonColor: string;
+}
+interface ThemeLayoutVariables {
+    disableGlobalHeaderFooter: boolean;
+    headerHeight: string;
+    footerHeight: string;
+    menuWidth?: string;
+}
+interface ThemeStylingVariables {
+    inputTextSize: string;
+    inputLabelSize: string;
+    inputHeight: string;
+    inputBgColor: string;
+    inputPadding: string;
+    borderColor: string;
+    borderSize: string;
+    borderRadius: string;
+    tooltipBackgroundColor: string;
+    tooltipTextSize: string;
+    tooltipBorderSize: string;
+    tooltipBorderColor: string;
+    tooltipCaretSize?: string;
+}
+interface ThemeColorPaletteExtension {
+    className: string;
+    color?: string;
+    textColor?: string;
+}
+interface ThemeFont {
+    name: string;
+    id?: string;
+    source?: 'google' | 'adobe';
+    isDefault?: boolean;
+    isSerif?: boolean;
+}
+interface ThemeAccessibility {
+    enabled: boolean;
+    highlightColor: string;
+    highlightThickness: string;
+    highlightOffset: string;
+    hoverEnabled: boolean;
+}
+
+declare class ThemingService {
+    private localStorageService;
+    private themeChangeDetectionService;
+    private readonly defaultZIndexes;
+    /**
+     * Prefix used to build the key for local storage of the theme
+     */
+    private readonly THEME_KEY;
+    /**
+     * A private BehaviorSubject to store the loaded themes
+     */
+    private themes;
+    private $selectedTheme;
+    get selectedTheme(): Observable<Theme>;
+    /**
+     * Key for the product this is deployed into
+     */
+    protected applicationName: string;
+    /**
+     * Converts a JSON property name to snake case
+     *
+     * @param prop
+     */
+    private toSnakeCase;
+    private toKebabCase;
+    private convertUnderscoreToDash;
+    /**
+     * For the given color, it'll lighten or darken the color by the percentage supplied. Positive percent will lighten, negative to darken.
+     *
+     * @param color
+     * @param percent
+     */
+    private lightenDarkenColor;
+    /**
+     * Converts a hex value to a Javascript object with r,g, and b variables.
+     *
+     * @param hex
+     */
+    private hexToRgb;
+    /**
+     * Generates a random hex color
+     */
+    getRandomColor(): string;
+    /**
+     * On App Initialization (in app.component.ts, ngOnInit) call this to load themes and apply the user selected theme or default theme.
+     *
+     * @param applicationName
+     * @param themes
+     */
+    appInit(applicationName: string, themes: Theme[]): void;
+    /**
+     * Return the themes for the current app
+     */
+    getThemes(): Observable<Theme[]>;
+    /**
+     * Apply the selected theme
+     */
+    applySettings(): void;
+    /**
+     * Returns the user selected theme from local storage
+     */
+    getTheme(): Theme;
+    /**
+     * Persists the user selected theme in local storage
+     *
+     * @param settings
+     */
+    saveTheme(settings: Theme): void;
+    /**
+     * Writes the theme information to a style tag in the header so that the theme is applied.
+     *
+     * @param theme
+     * @param prefix
+     */
+    changeColors(theme: Theme, prefix?: string): void;
+    private addHashmark;
+    private addFonts;
+    private fontExists;
+    removeThemeFromHeader(prefix: string): void;
+    /**
+     * Determines the contrast between a given color and its auto-selected text color
+     *
+     * @param color
+     */
+    getContrast(color: string): number;
+    /**
+     * Calculates luminance
+     *
+     * @param r
+     * @param g
+     * @param b
+     */
+    private luminance;
+    private isDarkTheme;
+    /**
+     * Calculates the contrast
+     *
+     * @param rgb1
+     * @param rgb2
+     */
+    private contrast;
+    /**
+     * Returns the maximally contrasting text color for the supplied background color
+     *
+     * @param color
+     */
+    getTextColor(color: string): string;
+    /**
+     * Generates the CSS for each of the colors in the theme. Will write the base color and 9 light and dark variants of the given color.
+     *
+     * @param style
+     * @param color
+     * @param className
+     */
+    private generateColors;
+    getDefaultZIndexes(): Array<string>;
+    private createZIndexes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemingService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemingService>;
+}
+
+/**
+ * Service to allow for components/services to listen for theme changes
+ */
+declare class ThemeChangeDetectionService {
+    /**
+     * Subject that fires when the theme is changed
+     * @private
+     */
+    private readonly _themeChanged;
+    /**
+     * Dependency injection site
+     */
+    constructor();
+    /**
+     * Trigger a theme change event
+     */
+    changeTheme(): void;
+    /**
+     * Listen for theme change events
+     */
+    listen(): Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeChangeDetectionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeChangeDetectionService>;
+}
+
+/**
+ * Pipe to transform an input number into its ordinal format
+ */
+declare class OrdinalNumberPipe implements PipeTransform {
+    /**
+     * Transform the input number/string (must be a valid number if string)
+     * into Ordinal format (1 -> 1st, 2 -> 2nd, etc)
+     * @param value the number to transform
+     */
+    transform(value: number | string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrdinalNumberPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<OrdinalNumberPipe, "ordinalNumber", true>;
+}
+
+/**
+ * Auditable Class - Holds the creation and modification data that is known for most DB interactions
+ */
+interface Auditable {
+    /**
+     * Who Created it
+     */
+    createdBy: string;
+    /**
+     * When it was created
+     */
+    createdTime: Date;
+    /**
+     * Who last modified it
+     */
+    modifiedBy: string;
+    /**
+     * When it was last modified
+     */
+    modifiedTime: Date;
+}
+
+/**
+ * The Data List is a wrapper class of Arrays returned from an endpoint. This makes it easy to unpack the list automagically.
+ */
+interface DataList<T> {
+    /**
+     * The field that holds a List of data
+     */
+    data: T[];
+}
+
+/**
+ * Wrapper class that holds an ID when a POST operation is completed
+ */
+interface Id {
+    /**
+     * The ID
+     */
+    id: any;
+}
+
+declare class ObservableContainer<T> {
+    private _subject;
+    private readonly _obs;
+    constructor(obs: Observable<T>);
+    refresh(): void;
+    get observable(): Observable<T>;
+}
+
+export { AccordionComponent, AccordionContentDirective, AccordionHeaderDirective, AccordionItemDirective, BackgroundCarouselDirective, BaseDataService, CalendarComponent, CheckboxComponent, ColorPickerComponent, DatePickerComponent, DateRangePickerComponent, DialogComponent, DialogService, DropdownComponent, INPUTMASK_VALUE_ACCESSOR, IconSelectComponent, IdleTimeoutComponent, InputMaskComponent, JsonInterceptor, KeyfilterDirective, LayoutFullFramingComponent, LayoutFullwidthSidebarComponent, LoaderComponent, LocalStorageService, MultiSelectComponent, NotificationComponent, NotificationService, ObservableContainer, OrdinalNumberPipe, PaginatorComponent, ParticleIconsModule, PopoverComponent, ProfilePicComponent, ProgressBarComponent, RICH_TEXT_VALUE_ACCESSOR, RadioButtonsComponent, RichTextComponent, ScrollToTopComponent, SlideoverComponent, SliderComponent, ThemeChangeDetectionService, ThemingService, ToggleSwitchComponent, TooltipDirective, WeekPickerComponent, Z_INDEX_LAYERS };
+export type { Auditable, CarouselOptions, DataList, DropdownOption, DropdownOptionGroup, Id, Interval, MultiSelectOption, MultiSelectOptionGroup, Notification, PaginationEvent, RichTextCapabilities, Theme, ThemeAccessibility, ThemeButtonColorPalette, ThemeColorPalette, ThemeColorPaletteExtension, ThemeFont, ThemeLayoutColors, ThemeLayoutVariables, ThemeStylingVariables, ToggleOptions };