@entake/particle 17.0.0

package/app/modules/rich-text/rich-text.component.d.ts

@@ -0,0 +1,48 @@
+import { AfterViewInit, EventEmitter } from '@angular/core';
+import { Editor } from '@tiptap/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { RichTextEditorText } from '../../shared/models/particle-component-text.model';
+import { RichTextCapabilities } from './rich-text-capabilities.model';
+import * as i0 from "@angular/core";
+export declare const RICH_TEXT_VALUE_ACCESSOR: any;
+export declare class RichTextComponent implements ControlValueAccessor, AfterViewInit {
+    placeholder: string;
+    hideControls: boolean;
+    height: string;
+    get readonly(): boolean;
+    set readonly(readonly: boolean);
+    text: RichTextEditorText;
+    capabilities: RichTextCapabilities;
+    borderRadius: string;
+    textChanged: EventEmitter<{
+        htmlValue: string;
+        textValue: string;
+    }>;
+    showDialog: any;
+    dialogLink: 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;
+    editor: Editor;
+    get value(): any;
+    set value(value: string);
+    ngAfterViewInit(): void;
+    onBlur(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    openLinkDialog(): void;
+    changeEditorLink(action: string): void;
+    focus(position?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RichTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RichTextComponent, "particle-rich-text", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "hideControls": { "alias": "hideControls"; "required": false; }; "height": { "alias": "height"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "text": { "alias": "text"; "required": false; }; "capabilities": { "alias": "capabilities"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; }, { "textChanged": "textChanged"; }, never, never, false, never>;
+}

package/app/modules/scroll-to-top/particle-scroll-to-top.module.d.ts

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

package/app/modules/scroll-to-top/scroll-to-top.component.d.ts

@@ -0,0 +1,19 @@
+import { AfterViewInit, OnDestroy, Renderer2 } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ScrollToTopText } from '../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+export declare class ScrollToTopComponent implements OnDestroy, AfterViewInit {
+    renderer: Renderer2;
+    content: HTMLElement;
+    scrollDistance: number;
+    bottomOffset: number;
+    text: ScrollToTopText;
+    $scrollTop: BehaviorSubject<number>;
+    private _listener;
+    constructor(renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    scrollToTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToTopComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollToTopComponent, "particle-scroll-to-top", never, { "content": { "alias": "content"; "required": false; }; "scrollDistance": { "alias": "scrollDistance"; "required": false; }; "bottomOffset": { "alias": "bottomOffset"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/slideover/particle-slideover.module.d.ts

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

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

@@ -0,0 +1,35 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { SlideoverText } from '../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+export declare class SlideoverComponent implements AfterViewInit, OnDestroy {
+    private _position;
+    slideoverOpen: boolean;
+    visible: boolean;
+    set position(position: string);
+    get position(): string;
+    modal: boolean;
+    width: string;
+    height: string;
+    bgClass: string;
+    text: SlideoverText;
+    /**
+     * Breakpoint that will make the container take over the screen when it's crossed.
+     */
+    breakpoint: number;
+    opened: EventEmitter<any>;
+    closed: EventEmitter<any>;
+    overlay: ElementRef;
+    breakpointExceeded: boolean;
+    constructor();
+    onResize(event: any): void;
+    private _determineBreakpointExceeded;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    private addModalMask;
+    private removeModalMask;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideoverComponent, "particle-slideover", never, { "position": { "alias": "position"; "required": false; }; "modal": { "alias": "modal"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "bgClass": { "alias": "bgClass"; "required": false; }; "text": { "alias": "text"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,143 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { SliderText } from '../../shared/models/particle-component-text.model';
+import * as i0 from "@angular/core";
+/**
+ * Component that wraps the native HTML5 slider
+ */
+export 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);
+    /**
+     * 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
+     */
+    unit: string;
+    /**
+     * The aria-label to append to the slider/input
+     */
+    ariaLabel: string;
+    text: SliderText;
+    /**
+     * Event emitted on slider/slider input input event
+     */
+    input: EventEmitter<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;
+    /**
+     * 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(changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Get the value of the component
+     */
+    get value(): number;
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
+    static ɵcmp: i0.ɵɵ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; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "input": "input"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./slider.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+export declare class ParticleSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleSliderModule, [typeof i1.SliderComponent], [typeof i2.CommonModule, typeof i3.FormsModule], [typeof i1.SliderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleSliderModule>;
+}

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

@@ -0,0 +1,43 @@
+import { ThemingService } from '../services/theming.service';
+import { Theme } from '../models/theme.model';
+import { DropdownOption } from '../../dropdown/models/dropdown-option.model';
+import { ThemingText } from '../../../shared/models/particle-component-text.model';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * This will produce a dropdown that can be embedded to allow a user to choose their theme.
+ */
+export declare class ThemingComponent {
+    private themingService;
+    /**
+     * Constructor
+     *
+     * @param themingService
+     */
+    constructor(themingService: ThemingService);
+    /**
+     * Override class for the embedded dropdown
+     */
+    selectClass: string;
+    /**
+     * ID for the embedded dropdown (allows for linking a label)
+     */
+    selectId: string;
+    text: ThemingText;
+    /**
+     * Selected Theme ID
+     */
+    private _themeId;
+    /**
+     * List of available themes
+     */
+    readonly options$: Observable<Array<DropdownOption>>;
+    readonly themes$: Observable<Array<Theme>>;
+    readonly selectedTheme$: Observable<Theme>;
+    /**
+     * Update the user's selected theme
+     */
+    changeTheme(selectedValue: string | number, themes: Array<Theme>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThemingComponent, "particle-theming", never, { "selectClass": { "alias": "selectClass"; "required": false; }; "selectId": { "alias": "selectId"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}

package/app/modules/theming/models/theme.model.d.ts

@@ -0,0 +1,88 @@
+export declare const Z_INDEX_LAYERS: {
+    BASE: string;
+    FRAME: string;
+    OVERLAY: string;
+    DIALOG: string;
+    NOTIFICATION: string;
+};
+export 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>;
+}
+export interface ThemeLayoutColors {
+    menuColor: string;
+    headerColor: string;
+    footerColor: string;
+    bodyColor: string;
+    contentColor: string;
+}
+export interface ThemeColorPalette {
+    bgRed: string;
+    bgOrange: string;
+    bgYellow: string;
+    bgGreen: string;
+    bgBlue: string;
+    bgPurple: string;
+    bgBrown: string;
+    bgGrey: string;
+    extension: Array<ThemeColorPaletteExtension>;
+}
+export interface ThemeButtonColorPalette {
+    okButtonColor: string;
+    cancelButtonColor: string;
+    deleteButtonColor: string;
+    saveButtonColor: string;
+    nextButtonColor: string;
+    previousButtonColor: string;
+    openButtonColor: string;
+    closeButtonColor: string;
+}
+export interface ThemeLayoutVariables {
+    disableGlobalHeaderFooter: boolean;
+    headerHeight: string;
+    footerHeight: string;
+    menuWidth?: string;
+}
+export 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;
+}
+export interface ThemeColorPaletteExtension {
+    className: string;
+    color?: string;
+    textColor?: string;
+}
+export interface ThemeFont {
+    name: string;
+    id?: string;
+    source?: 'google' | 'adobe';
+    isDefault?: boolean;
+    isSerif?: boolean;
+}
+export interface ThemeAccessibility {
+    enabled: boolean;
+    highlightColor: string;
+    highlightThickness: string;
+    highlightOffset: string;
+    hoverEnabled: boolean;
+}

package/app/modules/theming/services/theme-change-detection.service.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service to allow for components/services to listen for theme changes
+ */
+export 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: i0.ɵɵFactoryDeclaration<ThemeChangeDetectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeChangeDetectionService>;
+}

package/app/modules/theming/services/theming.service.d.ts

@@ -0,0 +1,142 @@
+import { Observable } from 'rxjs';
+import { Theme } from '../models/theme.model';
+import { ThemeChangeDetectionService } from './theme-change-detection.service';
+import { LocalStorageService } from '../../../shared/services/local-storage.service';
+import * as i0 from "@angular/core";
+export 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;
+    /**
+     * Constructor
+     *
+     * @param localStorageService
+     * @param themeChangeDetectionService
+     */
+    constructor(localStorageService: LocalStorageService, themeChangeDetectionService: ThemeChangeDetectionService);
+    /**
+     * 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;
+    /**
+     * Constructs a theme object based on another theme object
+     *
+     * @param theme
+     */
+    generateTheme(theme?: Theme): Theme;
+    /**
+     * Returns a list of the color classes specifically based on the properties of the theme model
+     */
+    getClassesFromTheme(theme: Theme): string[];
+    /**
+     * 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: i0.ɵɵFactoryDeclaration<ThemingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemingService>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/theming.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/platform-browser/animations";
+import * as i6 from "../dropdown/dropdown.module";
+export declare class ParticleThemingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParticleThemingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ParticleThemingModule, [typeof i1.ThemingComponent], [typeof i2.CommonModule, typeof i3.BrowserModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.BrowserAnimationsModule, typeof i6.ParticleDropdownModule], [typeof i1.ThemingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ParticleThemingModule>;
+}

package/app/modules/toggle-switch/models/toggle-options.model.d.ts

@@ -0,0 +1,11 @@
+export interface ToggleOptions {
+    affirmativeColorClass?: string;
+    affirmativeLabel?: string;
+    affirmativeIcon?: string;
+    negativeColorClass?: string;
+    negativeLabel?: string;
+    negativeIcon?: string;
+    accessibilityLabel?: string;
+    toggleSwitchWidth: number;
+    toggleTrackWidth: number;
+}

package/app/modules/toggle-switch/toggle-switch.component.d.ts

@@ -0,0 +1,43 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ToggleOptions } from './models/toggle-options.model';
+import * as i0 from "@angular/core";
+export declare class ToggleSwitchComponent implements ControlValueAccessor {
+    private changeDetectorRef;
+    private _options$;
+    options$: import("rxjs").Observable<ToggleOptions>;
+    set options(options: ToggleOptions);
+    disabled: boolean;
+    change: EventEmitter<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;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    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: i0.ɵɵFactoryDeclaration<ToggleSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleSwitchComponent, "particle-toggle-switch", never, { "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
+}

package/app/modules/toggle-switch/toggle-switch.module.d.ts

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