@entake/particle 17.0.0

package/app/modules/input-mask/input-mask.component.d.ts

@@ -0,0 +1,86 @@
+import { ElementRef, OnInit, EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const INPUTMASK_VALUE_ACCESSOR: any;
+export 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: Function;
+    onModelTouched: Function;
+    constructor();
+    ngOnInit(): void;
+    get mask(): string;
+    set mask(val: string);
+    initMask(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): 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: i0.ɵɵFactoryDeclaration<InputMaskComponent, never>;
+    static ɵcmp: i0.ɵɵ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, false, never>;
+}

package/app/modules/input-mask/input-mask.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-mask.component";
+import * as i2 from "@angular/common";
+export declare class ParticleInputMaskModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleInputMaskModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleInputMaskModule, [typeof i1.InputMaskComponent], [typeof i2.CommonModule], [typeof i1.InputMaskComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleInputMaskModule>;
+}

package/app/modules/keyfilter/keyfilter.directive.d.ts

@@ -0,0 +1,60 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to apply key filtering to an HTML input element
+ */
+export 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;
+    /**
+     * The type of filtering to apply
+     */
+    filterType: 'alpha' | 'numeric' | 'alphanumeric' | 'digits';
+    /**
+     * Whether or not to allow spaces (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;
+    /**
+     * Dependency injection site
+     * @param hostElement
+     */
+    constructor(hostElement: ElementRef<HTMLInputElement>);
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<KeyfilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeyfilterDirective, "[particleKeyfilter]", never, { "filterType": { "alias": "particleKeyfilter"; "required": false; }; "allowSpaces": { "alias": "allowSpaces"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/keyfilter/keyfilter.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./keyfilter.directive";
+import * as i2 from "@angular/common";
+export declare class ParticleKeyfilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleKeyfilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleKeyfilterModule, [typeof i1.KeyfilterDirective], [typeof i2.CommonModule], [typeof i1.KeyfilterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleKeyfilterModule>;
+}

package/app/modules/layout/components/layout-full-framing/layout-full-framing.component.d.ts

@@ -0,0 +1,27 @@
+import { TemplateRef } from '@angular/core';
+import { SlideoverComponent } from '../../../slideover/slideover.component';
+import * as i0 from "@angular/core";
+export declare class LayoutFullFramingComponent {
+    mainContent: TemplateRef<any>;
+    rightSidebar: TemplateRef<any>;
+    header: TemplateRef<any>;
+    footer: TemplateRef<any>;
+    mainContentContainerClassList: string;
+    rightSidebarContainerClassList: string;
+    headerClassList: string;
+    footerClassList: string;
+    headerHeight: string;
+    footerHeight: string;
+    rightSidebarWidth: string;
+    breakpoint: number;
+    rightSidebarCollapsedTabOffset: number;
+    collapsedClassList: string;
+    slideover: SlideoverComponent;
+    onResize(event: any): void;
+    protected readonly window: Window & typeof globalThis;
+    get stickySidebarHeight(): string;
+    get contentSidebarHeight(): string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutFullFramingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutFullFramingComponent, "particle-layout-full-framing", never, { "mainContent": { "alias": "mainContent"; "required": false; }; "rightSidebar": { "alias": "rightSidebar"; "required": false; }; "header": { "alias": "header"; "required": false; }; "footer": { "alias": "footer"; "required": false; }; "mainContentContainerClassList": { "alias": "mainContentContainerClassList"; "required": false; }; "rightSidebarContainerClassList": { "alias": "rightSidebarContainerClassList"; "required": false; }; "headerClassList": { "alias": "headerClassList"; "required": false; }; "footerClassList": { "alias": "footerClassList"; "required": false; }; "headerHeight": { "alias": "headerHeight"; "required": false; }; "footerHeight": { "alias": "footerHeight"; "required": false; }; "rightSidebarWidth": { "alias": "rightSidebarWidth"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "rightSidebarCollapsedTabOffset": { "alias": "rightSidebarCollapsedTabOffset"; "required": false; }; "collapsedClassList": { "alias": "collapsedClassList"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/layout/components/layout-fullwidth-sidebar/layout-fullwidth-sidebar.component.d.ts

@@ -0,0 +1,23 @@
+import { TemplateRef } from '@angular/core';
+import { SlideoverComponent } from '../../../slideover/slideover.component';
+import * as i0 from "@angular/core";
+export declare class LayoutFullwidthSidebarComponent {
+    mainContent: TemplateRef<any>;
+    rightSidebar: TemplateRef<any>;
+    mainContentContainerClassList: string;
+    rightSidebarContainerClassList: string;
+    rightSidebarSticky: boolean;
+    headerHeight: string;
+    footerHeight: string;
+    rightSidebarWidth: string;
+    breakpoint: number;
+    rightSidebarCollapsedTabOffset: number;
+    collapsedClassList: string;
+    slideover: SlideoverComponent;
+    onResize(event: any): void;
+    protected readonly window: Window & typeof globalThis;
+    get stickySidebarHeight(): string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutFullwidthSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutFullwidthSidebarComponent, "particle-layout-fullwidth-sidebar", never, { "mainContent": { "alias": "mainContent"; "required": false; }; "rightSidebar": { "alias": "rightSidebar"; "required": false; }; "mainContentContainerClassList": { "alias": "mainContentContainerClassList"; "required": false; }; "rightSidebarContainerClassList": { "alias": "rightSidebarContainerClassList"; "required": false; }; "rightSidebarSticky": { "alias": "rightSidebarSticky"; "required": false; }; "headerHeight": { "alias": "headerHeight"; "required": false; }; "footerHeight": { "alias": "footerHeight"; "required": false; }; "rightSidebarWidth": { "alias": "rightSidebarWidth"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "rightSidebarCollapsedTabOffset": { "alias": "rightSidebarCollapsedTabOffset"; "required": false; }; "collapsedClassList": { "alias": "collapsedClassList"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/layout/layout.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/layout-fullwidth-sidebar/layout-fullwidth-sidebar.component";
+import * as i2 from "./components/layout-full-framing/layout-full-framing.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../slideover/particle-slideover.module";
+export declare class ParticleLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleLayoutModule, [typeof i1.LayoutFullwidthSidebarComponent, typeof i2.LayoutFullFramingComponent], [typeof i3.CommonModule, typeof i4.ParticleSlideoverModule], [typeof i1.LayoutFullwidthSidebarComponent, typeof i2.LayoutFullFramingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleLayoutModule>;
+}

package/app/modules/loader/components/loader.component.d.ts

@@ -0,0 +1,11 @@
+import { LoaderText } from '../../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+export declare class LoaderComponent {
+    text: LoaderText;
+    disableText: boolean;
+    protected backgroundStyle: string | undefined;
+    private _colors;
+    set colors(colors: Array<string>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "particle-loader", never, { "text": { "alias": "text"; "required": false; }; "disableText": { "alias": "disableText"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/loader/loader.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/loader.component";
+import * as i2 from "@angular/common";
+export declare class ParticleLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleLoaderModule, [typeof i1.LoaderComponent], [typeof i2.CommonModule], [typeof i1.LoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleLoaderModule>;
+}

package/app/modules/multi-select/models/multi-select-option-group.model.d.ts

@@ -0,0 +1,16 @@
+import { MultiSelectOption } from './multi-select-option.model';
+/**
+ * Interface representing an array of multi-select options
+ * grouped under a label
+ */
+export interface MultiSelectOptionGroup {
+    type?: 'group';
+    /**
+     * The option group label
+     */
+    groupLabel: string;
+    /**
+     * The group options
+     */
+    options: Array<MultiSelectOption>;
+}

package/app/modules/multi-select/models/multi-select-option.model.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Interface representing a multi-select option
+ */
+export 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;
+    };
+}

package/app/modules/multi-select/multi-select.component.d.ts

@@ -0,0 +1,279 @@
+import { AnimationEvent } from '@angular/animations';
+import { ChangeDetectorRef, ElementRef, EventEmitter, QueryList, Renderer2, TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MultiSelectOption } from './models/multi-select-option.model';
+import { MultiSelectOptionGroup } from './models/multi-select-option-group.model';
+import { MultiSelectText } from '../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+/**
+ * Type representing the multi-select component option input
+ */
+declare type MultiSelectOptionInput = Array<MultiSelectOption | MultiSelectOptionGroup>;
+/**
+ * Multi-select component
+ */
+export 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: boolean;
+    /**
+     * Class list to assign to the multi-select
+     */
+    classList: string;
+    buttonClassList: string;
+    entryClassList: string;
+    text: MultiSelectText;
+    /**
+     * Style of the multi-select
+     */
+    type: 'input' | 'expanded';
+    maxExpandedEntries: number;
+    expandedAsGrid: boolean;
+    collapsedButtonTemplate: TemplateRef<any>;
+    /**
+     * Event emitted on value change, emits the new value
+     */
+    change: EventEmitter<(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<{
+        [value: string]: {
+            [key: string]: unknown;
+        };
+    }>;
+    /**
+     * Observable map of stringified option value to boolean indicating the user's selections
+     */
+    readonly selectionValueMap$: Observable<{
+        [key: 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(renderer: Renderer2, changeDetectorRef: ChangeDetectorRef);
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectComponent, "particle-multi-select", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "classList": { "alias": "classList"; "required": false; }; "buttonClassList": { "alias": "buttonClassList"; "required": false; }; "entryClassList": { "alias": "entryClassList"; "required": false; }; "text": { "alias": "text"; "required": false; }; "type": { "alias": "type"; "required": false; }; "maxExpandedEntries": { "alias": "maxExpandedEntries"; "required": false; }; "expandedAsGrid": { "alias": "expandedAsGrid"; "required": false; }; "collapsedButtonTemplate": { "alias": "collapsedButtonTemplate"; "required": false; }; }, { "change": "change"; }, ["template"], ["template"], false, never>;
+}
+export {};

package/app/modules/multi-select/multi-select.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./multi-select.component";
+import * as i2 from "@angular/common";
+export declare class ParticleMultiSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleMultiSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleMultiSelectModule, [typeof i1.MultiSelectComponent], [typeof i2.CommonModule], [typeof i1.MultiSelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleMultiSelectModule>;
+}

package/app/modules/notification/models/notification.model.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Model representing a notification
+ */
+export 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;
+}

package/app/modules/notification/notification.component.d.ts

@@ -0,0 +1,46 @@
+import { Observable } from 'rxjs';
+import { Notification } from './models/notification.model';
+import { NotificationService } from './services/notification.service';
+import { NotificationText } from '../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+/**
+ * Component for displaying notifications
+ */
+export declare class NotificationComponent {
+    private service;
+    /**
+     * Dependency injection site
+     * @param service the NotificationService
+     */
+    constructor(service: NotificationService);
+    text: NotificationText;
+    /**
+     * Array of notifications as an Observable
+     */
+    readonly notifications$: Observable<Array<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: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "particle-notification", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/notification/notification.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./notification.component";
+import * as i2 from "@angular/common";
+export declare class ParticleNotificationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleNotificationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleNotificationModule, [typeof i1.NotificationComponent], [typeof i2.CommonModule], [typeof i1.NotificationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleNotificationModule>;
+}