@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1441

package/lib/display/dialog/dialog-group/dialog-group.component.d.ts

@@ -0,0 +1,32 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { DialogOpenStartEvent } from '../dialog-types';
+import { DialogService } from '../dialog.service';
+import * as i0 from "@angular/core";
+export declare class DialogGroupComponent implements OnInit, OnDestroy {
+    private dialogService;
+    activeDialogEvents: DialogOpenStartEvent<any>[];
+    private destroyed;
+    constructor(dialogService: DialogService);
+    /**When the group component is created, start watching for any DialogOpenStart events
+     * so that the group can react and make the matching dialog. New dialogs get assigned unique
+     * eventIds so that when they close we know exactly which one is done and we can take it
+     * out of the list of active dialogs
+     */
+    ngOnInit(): void;
+    /** When the dialog group is destroyed we no longer want to listen for any open events. */
+    ngOnDestroy(): void;
+    /**The dialog component completed opening (including animation delay) and
+     * emits an event that tells us it is ready. The group can then pump out a dialog
+     * openEnd event (kinda NavigationEnd in the router) to tell anybody who cares that
+     * the dialog is now ready.
+     */
+    dialogOpened(dialogOpenEvent: DialogOpenStartEvent<any>, dialogId: string): void;
+    /** The dialog has closed (after animation delay) and emitted an event to tell the hosting component.
+     * We handle the event and pump a matching DialogCloseEvent so that anybody who cares can know that the
+     * dialog instance referenced by dialogOpenEvent.eventId is gone now. We remove it from our list of
+     * active dialogs which pulls it out of the DOM too
+     */
+    dialogClosed(dialogOpenEvent: DialogOpenStartEvent<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogGroupComponent, "ec-dialog-group", never, {}, {}, never, never, false, never>;
+}

package/lib/display/dialog/dialog-types.d.ts

@@ -0,0 +1,130 @@
+import { TemplateRef, Type } from '@angular/core';
+import { DialogContent } from './dialog-content';
+/**A base class from which all dialog events extend. This class models the dialog actions very much
+ * like the Angular RouterEvents.
+ */
+export declare class DialogEvent {
+    /**A unique value representing this particular instance of the event, used to match open and close events together */
+    eventId?: string | undefined;
+    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
+     * Useful for telemetry logging to track users opening and closing dialogs
+    */
+    dialogId: string;
+    /** The action the dialog event represents. Can also be determined by using the class of the event with the
+     * instanceof operator.
+     */
+    dialogAction: 'openStart' | 'open' | 'close' | 'closeLatest';
+    constructor(
+    /**A unique value representing this particular instance of the event, used to match open and close events together */
+    eventId?: string | undefined, 
+    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
+     * Useful for telemetry logging to track users opening and closing dialogs
+    */
+    dialogId?: string, 
+    /** The action the dialog event represents. Can also be determined by using the class of the event with the
+     * instanceof operator.
+     */
+    dialogAction?: 'openStart' | 'open' | 'close' | 'closeLatest');
+}
+/**Emitted when the dialog open has been triggered, but the dialog itself hasn't initialized yet.
+ * This event creates its own unique identifier so that that particular instance of the dialog can be found
+ * when closed later on. The context is used to fill the dialog itself, and may include state or callbacks.
+ * Various options are available to change the dialog appearance. These events are generally created
+ * by the @see DialogService.open() call
+ */
+export declare class DialogOpenStartEvent<T> extends DialogEvent {
+    content: Type<DialogContent<T>> | TemplateRef<any>;
+    context?: T | undefined;
+    options?: DialogOptions | undefined;
+    constructor(content: Type<DialogContent<T>> | TemplateRef<any>, context?: T | undefined, options?: DialogOptions | undefined);
+}
+/**Emitted when the dialog has finished opening and been properly initialized. It includes
+ * the eventId, which uniquely identifies the particular instance of the dialog open event so that we can
+ * close that specific dialog later on. The dialogId can be used for telemetry, and may be set to something
+ * like "Confirm Delete" or "Edit Reading" etc.
+ */
+export declare class DialogOpenEndEvent extends DialogEvent {
+    constructor(eventId?: string, dialogId?: string);
+}
+/**Emitted when the dialog close has completed and a result is available. Check result.save to know if the dialog change
+ * was committed (true) or cancelled (false). Cancel can be set if the dialog was automatically closed by clicking in the
+ * background or resizing the window when using the panel view or closeOnResize.
+ */
+export declare class DialogCloseEvent<T> extends DialogEvent {
+    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
+    dialogResult: DialogResult<any>;
+    constructor(eventId?: string, dialogId?: string, save?: boolean, context?: T);
+}
+/**Used to tell the dialog group to close whatever dialog was opened most recently with the given result
+ * This allows a TemplateRef based panel (that's not coming from DialogComponent) to close itself or
+ * an external process to close a dialog that is open
+ */
+export declare class DialogCloseLatestEvent<T> extends DialogEvent {
+    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
+    dialogResult: DialogResult<any>;
+    constructor(result: DialogResult<T>);
+}
+/**
+ * This interface specifies extra options to configure behavior of the Dialog Component
+ */
+export interface DialogOptions {
+    /**
+     * Function to execute before dialog opens.  Leave `undefined` or return true to allow
+     * dialog to open.
+     *
+     * Can be used to check for unsaved changes on the underlying page before opening.
+     *
+     * @example
+       constructor( private unsavedChangesGuard: CanDeactivateUnsavedChangesGuard ){};
+       //...
+       const options: DialogOptions = { canOpenDialog: this.unsavedChangesGuard.canDeactivate };
+     */
+    canOpenDialog?: () => Promise<boolean>;
+    /** Configures when the dialog emits its result in relation to a closing animation event */
+    emitResultOn?: DialogAnimationEvent;
+    /** Display the dialog as a side panel that slides in */
+    displayAsPanel?: boolean;
+    /** Set the dialog mask color to transparent. Defaults to true when dialog is displayed as a panel */
+    transparentMask?: boolean;
+    /**
+     * Set the dialog mask to not display at all. Allows the user to click on elements behind the dialog.
+     * Only applicable when displayAsPanel is true.
+     * Defaults to false.
+     */
+    noMask?: boolean;
+    /** Align the dialog window to the top instead of centered. */
+    alignToTop?: boolean;
+    /** Set the top margin of the dialog window. Only takes effect if alignToTop is true.
+     * Must include units, i.e. "32rem" or "10vh"
+     */
+    alignToTopMargin?: string;
+    /**
+     * Set to true if the dialog should automatically close when the window is resized.
+     * This is useful if you are conditionally showing/hiding the dialog content as a static part of the page
+     * when the screen gets wide enough
+     */
+    closeOnResize?: boolean;
+    size?: DialogSize;
+    /**
+     * Used to specify a custom min-width of the dialog. Only takes effect if size is set to dynamic.
+     * Must include units, i.e. "32rem" or "640px"
+     */
+    minWidth?: string;
+}
+/**
+ * Returned when a dialog is closed.
+ * Specifies if the dialog was saved and contains an optional context.
+ */
+export declare class DialogResult<T> {
+    save: boolean;
+    context?: T | undefined;
+    constructor(save: boolean, context?: T | undefined);
+}
+/** Options for size of dialog */
+export type DialogSize = number | 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'full' | 'dynamic';
+/**
+ * Dialog Animation Events:
+ * - BeginClose: When the close animation starts.
+ * - EndClose: When the close animation finishes
+ */
+export type DialogAnimationEvent = 'BeginClose' | 'EndClose';

package/lib/display/dialog/dialog.component.d.ts

@@ -0,0 +1,120 @@
+import { ComponentFactoryResolver, ComponentRef, EventEmitter, Type, ViewContainerRef, TemplateRef } from '@angular/core';
+import { WindowService } from '../../core/window.service';
+import { DialogContent } from './dialog-content';
+import { DialogSize, DialogOptions, DialogResult } from './dialog-types';
+import { DialogService } from './dialog.service';
+import * as i0 from "@angular/core";
+/** These values need to be kept in sync with dialog-base.scss */
+export declare const DialogOpenDuration: number;
+export declare const DialogCloseDuration: number;
+export declare const PanelOpenDuration: number;
+export declare const PanelCloseDuration: number;
+export declare class DialogComponent {
+    private componentFactoryResolver;
+    private windowService;
+    private dialogService;
+    private documentRef;
+    /**
+     * Add/remove the is-open css class to the host element when the dialog is opened/closed.
+     * Styles use the is-open class to show/hide the dialog.
+     */
+    isOpen: boolean;
+    /**
+     * Add the fade-in css class to the host element when the dialog is opening. Remove when transition is complete.
+     * Styles use the fade-in class to apply a fade-in transition while the dialog is opening.
+     */
+    fadeIn: boolean;
+    /**
+     * Add the fade-out css class to the host element when the dialog is closing. Remove when transition is complete.
+     * Styles use the fade-out class to apply a fade-out transition while the dialog is closing.
+     */
+    fadeOut: boolean;
+    displayAsPanel: boolean;
+    alignToTop: boolean;
+    alignToTopMargin?: string;
+    transparentMask: boolean;
+    noMask: boolean;
+    onOverlayClick(event: MouseEvent): void;
+    /**
+     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+     */
+    set size(value: DialogSize);
+    get size(): DialogSize;
+    /**
+     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+     */
+    private _size;
+    /**
+     * Bound to the host. The classes set the --ec-dialog-width variable to our default 'small', 'medium', etc. sizes.
+     * Undefined when the size is a number, which is used for custom sizes.
+     */
+    dialogSizeClass?: string;
+    content?: Type<DialogContent<any>> | TemplateRef<any>;
+    context?: any;
+    options?: DialogOptions;
+    /**Only set if this particular instance of a dialog should be identified separately from others.
+     * If provided, this is emitted to the dialog service with OpenEnd and Close events. Direct usage
+     * of the DialogComponent from outside a DialogGroup does not usually require using this parameter as
+     * the dialog reference itself functions as the identifier
+     */
+    dialogOpenStartEventId?: string;
+    /**
+     * Emits an event when the dialog is opened
+     */
+    opened: EventEmitter<string>;
+    /**
+     * Emits an event when the dialog is closed
+     */
+    closed: EventEmitter<DialogResult<any>>;
+    /**
+     * The container where the component will be loaded
+     */
+    contentContainer: ViewContainerRef;
+    /**
+     * Custom width of the dialog in pixels. Set by defining the size property
+     * as a number value.
+     */
+    width?: number;
+    /**
+     * Custom min-width of the dialog. Only takes effect if size is set to dynamic.
+     * Must include units, i.e. "32rem" or "640px"
+     */
+    minWidth?: string;
+    /**
+     * A reference of the component once it has been loaded
+     */
+    componentRef?: ComponentRef<any>;
+    private previouslyFocusedElement;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, windowService: WindowService, dialogService: DialogService, documentRef: Document);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Clear and previously loaded content
+     * Load the component
+     * Save a reference of the loaded component
+     * Show the dialog and fade in
+     */
+    open<T>(component: Type<DialogContent<T>> | TemplateRef<any>, context?: T, options?: DialogOptions): Promise<void>;
+    /**
+     * Fade the dialog out and hide
+     */
+    close<T>(result?: DialogResult<T>): void;
+    /**Open the dialog and attach handlers to the cancel and save events to close it and notify the hosting page */
+    private openDialogComponent;
+    /**
+     * Reset options so they don't persist next time the
+     * root dialog is opened
+     * @deprecated
+     */
+    private resetOptions;
+    /** If they turned on closeOnResize, automatically close the dialog any time somebody resizes the window.
+      * This is useful for responsive layouts to prevent having the dialogContent on the screen twice */
+    private handleCloseOnResize;
+    /**Extract the dialogId from the dialog content, if it has one. Template-based dialogs generally don't.
+     * We fall back to empty string to allow anybody listening for dialogEvents to still record the open/close even if
+     * the dialog itself does not say what the name is.
+     */
+    private getDialogId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "ec-dialog", never, { "size": { "alias": "size"; "required": false; }; "content": { "alias": "content"; "required": false; }; "context": { "alias": "context"; "required": false; }; "options": { "alias": "options"; "required": false; }; "dialogOpenStartEventId": { "alias": "dialogOpenStartEventId"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, false, never>;
+}

package/lib/display/dialog/dialog.service.d.ts

@@ -0,0 +1,48 @@
+import { TemplateRef, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ConfirmDialogContext } from '../confirm/confirm.component';
+import { DialogContent } from './dialog-content';
+import { DialogEvent, DialogOptions, DialogResult, DialogSize } from './dialog-types';
+import * as i0 from "@angular/core";
+/**
+ * Service used to communcate with ng5 dialogs from an ng1 view. Any dialogs that
+ * have been added to ng1 views must be added to the DialogCatalog in order
+ * to know which component to load inside the dialog. You can also optionally subscribe
+ * to an onClose event to do some work after the dialog closes
+ */
+export declare class DialogService {
+    /**
+     * Emits DialogEvents when the dialog opens or closes.
+     */
+    events: Observable<DialogEvent>;
+    /**
+     * Open the root dialog.
+     * @param content - The component class to load into the dialog
+     * @param size - The size of the dialog
+     * @param context - optional context to pass to the dialog content during initialization.
+     * @param options - extra options to configure the dialog
+     * @returns Observable of a typed DialogResult which specifies if the dialog was saved and an optional context.
+     * @example
+        // From typescript
+        try {
+          const result = await lastValueFrom(this.dialogService.openDialog(MyComponent, 'small', myContext, options));
+          // do something with result
+        } catch(error) {
+          // do something with error
+        }
+     */
+    openDialog<T>(content: Type<DialogContent<T>> | TemplateRef<any>, size: DialogSize, context?: T, options?: DialogOptions): Observable<DialogResult<T>>;
+    /**Close whatever dialog was most recently opened, with the provided result.
+     * The result must be in a form the caller can expect (must match the dialog) so use this carefully
+     * if you are returning any result other than cancel. It is most useful if you are opening
+     * a dialog with a template reference instead of a true dialog child component
+     */
+    closeLatestDialog<T>(result: DialogResult<T>): void;
+    /**
+     * Open a Confirmation Dialog with the given context
+     */
+    confirm(context: ConfirmDialogContext): Observable<DialogResult<ConfirmDialogContext>>;
+    triggerEvent(event: DialogEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}

package/lib/display/help/help-types.d.ts

@@ -0,0 +1,33 @@
+export type Help = {
+    controls: HelpControl[];
+    overview?: string;
+    alwaysVisible?: boolean;
+    ignoreUserSetting?: boolean;
+};
+/**
+ * A form control in the current view to define in the help panel
+ */
+export type HelpControl = {
+    /**
+     * The controls id
+     * @type {string}
+     */
+    id: string;
+    /**
+     * The form control ids to match this help control
+     * If this array is defined the id's within this will take precidence over the
+     * id of the help control when trying to match up a control
+     * @type {string[]}
+     */
+    idGroup?: Array<string>;
+    /**
+     * The name of the control
+     * @type {string}
+     */
+    label: string;
+    /**
+     * The definition for the control
+     * @type {string}
+     */
+    definition: string;
+};

package/lib/display/hierarchy/hierarchy-base.d.ts

@@ -0,0 +1,97 @@
+import { EventEmitter, Injector, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { Params, QueryParamsHandling } from '@angular/router';
+import { Subject } from 'rxjs';
+import { LinkItem } from '../../controls/navigation/link-item';
+import { TelemetryService } from '../../core/telemetry.service';
+import { ViewStatus } from '../../shared/display';
+import * as i0 from "@angular/core";
+export declare class HierarchyItem implements LinkItem {
+    id: string;
+    /** Label to display for the item */
+    label: string;
+    /** Text to be displayed in the item's tooltip. When not provided, the label will be displayed. */
+    tooltip?: string;
+    /** Text to be displayed in the item's icon tooltip. */
+    iconTooltip?: string;
+    /** Indicates how many levels deep the item is in the parent structure */
+    level: number;
+    url?: string;
+    queryParams?: Params | null;
+    queryParamsHandling?: QueryParamsHandling;
+    icon?: string;
+    /** Display item as a link, a heading, or with a divider line below it */
+    display?: 'default' | 'heading' | 'divider';
+    /** Set to hide toggle, even if item has children */
+    hideToggle?: boolean;
+    /** Flag to indicate whether the item has children or not, mostly drives
+     *  whether you get the expand/collapse button
+     */
+    hasChildren: boolean;
+    /** Array of children if any for the item */
+    children: Array<HierarchyItem>;
+    /** Flag to indicate if the item has been expanded */
+    expanded?: boolean;
+    /** Flag to indicate if the item is selected */
+    selected?: boolean;
+    /** Flag to indicate if the item can be selected */
+    selectable?: boolean;
+    readonly?: boolean;
+    /** Status of each item to indicate whether children lookup is pending or
+     *  if an error occurred retrieving data
+     */
+    status?: ViewStatus;
+    /** Indicates if the item is a top level entity, e.g. Organization or Cost Center */
+    topLevel?: boolean;
+    /**
+     * When checking the url for activeness, the url must match exactly or partially
+     * @see https://angular.io/guide/router#active-router-links
+     */
+    isActiveExactMatch?: boolean;
+    /**
+     * Reference to the parent item. Useful if you need to walk the tree in reverse. An example usage
+     * would be to expand all parent items above a node that is the current selection.
+     */
+    parentItem?: HierarchyItem;
+    /**
+     * Set to have no level indentation for the item. Useful for top level items in a tree that is not hierarchical
+     */
+    noIndent?: boolean | undefined;
+}
+/**
+ * Represents a HierarchyItem that has been clicked to toggle its expansion state.
+ */
+export type ToggledHierarchyItem = {
+    item: HierarchyItem;
+    expanded: boolean;
+};
+export declare abstract class HierarchyBase implements OnChanges, OnDestroy {
+    /** First item to start the hierarchy structure */
+    rootNode: HierarchyItem;
+    /** Event emitter to request children for a given item */
+    getItemChildren: EventEmitter<HierarchyItem>;
+    /** Event emitted when an item is toggled. */
+    itemToggled: EventEmitter<ToggledHierarchyItem>;
+    /**
+    * Used to unsubscribe from observables
+    */
+    private _destroyed;
+    get destroyed(): Subject<void>;
+    protected telemetryService: TelemetryService;
+    constructor(injector: Injector);
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+    * Function called when the component is destroyed
+    */
+    ngOnDestroy(): void;
+    /** Handler for the toggle button */
+    toggleItemClicked(item: HierarchyItem, expanded: boolean): void;
+    /** Method exposed to the parent component to set the items children once they are available
+     */
+    setItemChildren(parentItem: HierarchyItem, items: Array<HierarchyItem>): void;
+    /** Method exposed to the parent component to indicate that something happened on the
+     *  item that caused an error, could be retrieving children
+    */
+    setItemError(parentItem: HierarchyItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HierarchyBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HierarchyBase, never, never, { "rootNode": { "alias": "rootNode"; "required": false; }; }, { "getItemChildren": "getItemChildren"; "itemToggled": "itemToggled"; }, never, never, false, never>;
+}

package/lib/display/hierarchy/hierarchy-mocks.spec.d.ts

@@ -0,0 +1,53 @@
+import { HierarchyItem } from './hierarchy-base';
+export declare namespace HierarchyMocks {
+    const mockRoot: () => HierarchyItem;
+    const bldgWithChildren: () => {
+        placeId: number;
+        parentId: number;
+        placeTypeId: number;
+        placeCode: string;
+        placeInfo: string;
+        hasChildren: boolean;
+        placeChildren: never[];
+        meterChildren: never[];
+        hasActiveChildren: boolean;
+    };
+    const bldgWithChildrenHierarchyItem: () => HierarchyItem;
+    const orgWithChildren: () => {
+        placeId: number;
+        parentId: number;
+        placeTypeId: number;
+        placeCode: string;
+        placeInfo: string;
+        hasChildren: boolean;
+        placeChildren: never[];
+        meterChildren: never[];
+        hasActiveChildren: boolean;
+    };
+    const orgWithChildrenHierarchyItem: () => HierarchyItem;
+    const orgWithoutChildren: () => {
+        placeId: number;
+        parentId: number;
+        placeTypeId: number;
+        placeCode: string;
+        placeInfo: string;
+        hasChildren: boolean;
+        placeChildren: never[];
+        meterChildren: never[];
+        hasActiveChildren: boolean;
+    };
+    const orgWithoutChildrenHierarchyItem: () => HierarchyItem;
+    const bldgWithoutChildren: () => {
+        placeId: number;
+        parentId: number;
+        placeTypeId: number;
+        placeCode: string;
+        placeInfo: string;
+        hasChildren: boolean;
+        placeChildren: never[];
+        meterChildren: never[];
+        hasActiveChildren: boolean;
+    };
+    const bldgWithoutChildrenHierarchyItem: () => HierarchyItem;
+    const sortedHierarchyPlaces: () => HierarchyItem[];
+}

package/lib/display/hierarchy/hierarchy-tree/hierarchy-tree.component.d.ts

@@ -0,0 +1,34 @@
+import { Injector, OnInit, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ScrollService } from '../../../core/scroll.service';
+import { HierarchyBase, HierarchyItem } from '../hierarchy-base';
+import * as i0 from "@angular/core";
+export declare class HierarchyTreeComponent extends HierarchyBase implements OnInit {
+    private scrollService;
+    /** The value of the id attribute of the tree's root HTMLUListElement, suffixed with '_root' */
+    id: string;
+    /** Hide the root node */
+    hideRootNode?: boolean;
+    /** Custom item template to use in place of the default one */
+    customItemTemplate?: TemplateRef<any>;
+    /** Emits a HierarchyItem whenever one is selected by clicking */
+    itemSelected: Subject<HierarchyItem>;
+    /** The width of the spacing before a tree node, multipled by a HierarchyItem's level. Value is in pixels */
+    indent: number;
+    /** The value of the id attribute of the tree's scroll container element, used to scroll a selected item into view.  */
+    scrollContainerId: string;
+    constructor(scrollService: ScrollService, injector: Injector);
+    ngOnInit(): void;
+    /**
+     * Scroll to the item currently marked as is-selected. Wait a tick for the
+     * NavItemActiveDirective to update the selected class.
+     */
+    scrollToSelectedItem(): void;
+    /**
+     * When a HierarchyItem is selected, update the value of the activeUrl property with the value
+     * of that item's url property and emit the item to any subscribers.
+     */
+    selectItem(item: HierarchyItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HierarchyTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HierarchyTreeComponent, "ec-hierarchy-tree", never, { "id": { "alias": "id"; "required": false; }; "hideRootNode": { "alias": "hideRootNode"; "required": false; }; "customItemTemplate": { "alias": "customItemTemplate"; "required": false; }; }, { "itemSelected": "itemSelected"; }, never, never, false, never>;
+}

package/lib/display/item-display/item-display.component.d.ts

@@ -0,0 +1,43 @@
+import { PopoverContentPosition } from '../../controls/popover/popover.component';
+import { LinkTarget } from '../tags/tag';
+import * as i0 from "@angular/core";
+export type DisplayValue = {
+    value: string;
+    classnames?: string;
+    icon?: string;
+    noValueText?: string;
+    tooltip?: string;
+};
+export type HelpPopoverConfig = {
+    text: string;
+    contentPosition?: PopoverContentPosition;
+    maxWidth?: string;
+};
+export declare class ItemDisplayComponent {
+    /** The value of the host element's id attribute */
+    id: string;
+    label: string;
+    private _labelHelpPopover?;
+    set labelHelpPopover(labelHelpPopover: string | HelpPopoverConfig | undefined);
+    get labelHelpPopover(): HelpPopoverConfig | undefined;
+    set value(value: string | DisplayValue | undefined);
+    internalValue: DisplayValue;
+    /**
+     * When provided, displays the value as a link
+     */
+    set url(value: string | undefined);
+    get url(): string | undefined;
+    private _url?;
+    /**
+     * Set link as an href or routerLink
+     */
+    externalLink: boolean;
+    condensed: boolean;
+    /**
+     * The link target when url is provided. Defaults to _self (same window)
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a
+     */
+    target: LinkTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItemDisplayComponent, "ec-item-display", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelHelpPopover": { "alias": "labelHelpPopover"; "required": false; }; "value": { "alias": "value"; "required": false; }; "url": { "alias": "url"; "required": false; }; "condensed": { "alias": "condensed"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/display/json-display/json-display.component.d.ts

@@ -0,0 +1,16 @@
+import { OnChanges } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare class JsonDisplayComponent implements OnChanges {
+    private translate;
+    id?: string;
+    attrId?: string;
+    jsonString?: string;
+    maxLength: number;
+    jsonDisplay: UntypedFormControl;
+    constructor(translate: TranslateService);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonDisplayComponent, "ec-json-display", never, { "id": { "alias": "id"; "required": false; }; "jsonString": { "alias": "jsonString"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, {}, never, never, false, never>;
+}