@energycap/components 0.26.11 → 0.27.0

package/lib/components.module.d.ts

@@ -1,7 +1,6 @@
-import { ModuleWithProviders, Type } from '@angular/core';
-import { TelemetryBaseService } from './core/telemetry-base.service';
+import { ModuleWithProviders, Provider } from '@angular/core';
 export declare type ComponentsModuleConfig = {
-    telemetryService: Type<TelemetryBaseService>;
+    tracker: Provider;
 };
 export declare class ComponentsModule {
     /**

package/lib/core/cache.service.d.ts

@@ -1,4 +1,11 @@
 export declare class CacheService {
+    private localStorageAvailable;
+    private sessionStorageAvailable;
+    constructor();
+    /**Return true if the requested cache allows the user to round-trip data in the current environment.
+     * Security settings can prevent it and the app may need to know if "not found" means "never set" or "not supported"
+     */
+    isCacheAvailable(sessionOnly?: boolean): boolean;
     /**
      * Retrieve an item from cache
      */
@@ -15,6 +22,9 @@ export declare class CacheService {
      * Persists an item to cache
      */
     setItem(key: string, value: object, sessionOnly?: boolean): void;
-    /**Returns the local or session storage to use for backing the given cache request */
+    /**Returns the local or session storage to use for backing the given cache request.
+     * If the browser does not support the requested storage the result will be null.
+     * This can happen if the user is in Firefox for example with the setting dom.storage.enabled = false
+    */
     private getStorage;
 }

package/lib/core/telemetry-tracker.service.d.ts

@@ -0,0 +1,10 @@
+export declare class TelemetryTrackerService {
+    trackPageView(pageName: string, url: string, properties?: {
+        [key: string]: string | number;
+    }): void;
+    trackEvent(name: string, properties?: {
+        [key: string]: string;
+    }, measurements?: {
+        [val: string]: number;
+    }): void;
+}

package/lib/core/telemetry.service.d.ts

@@ -1,8 +1,25 @@
-import { TelemetryBaseService } from './telemetry-base.service';
-export declare class TelemetryService extends TelemetryBaseService {
+import { TelemetryTrackerService } from './telemetry-tracker.service';
+export declare class TelemetryService {
+    private telemetryTrackerService;
+    constructor(telemetryTrackerService: TelemetryTrackerService);
+    /**
+     * Tracks a Page View / State change
+     *
+     * @param {string} pageName
+     * @param {string} url
+     * @memberof TelemetryService
+     */
     trackPageView(pageName: string, url: string, properties?: {
         [key: string]: string | number;
     }): void;
+    /**
+     * Tracks a generic event
+     *
+     * @param {string} name
+     * @param {{[key: string]:string}} [properties]
+     * @param {{[val:string]:number}} [measurements]
+     * @memberof TelemetryService
+     */
     trackEvent(name: string, properties?: {
         [key: string]: string;
     }, measurements?: {

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

@@ -0,0 +1,33 @@
+export declare type Help = {
+    controls: HelpControl[];
+    overview?: string;
+    alwaysVisible?: boolean;
+    ignoreUserSetting?: boolean;
+};
+/**
+ * A form control in the current view to define in the help panel
+ */
+export declare 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,72 @@
+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';
+export declare class HierarchyItem implements LinkItem {
+    id: string;
+    /** Label to display for the item */
+    label: 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 or a heading */
+    display?: 'default' | 'heading';
+    /** 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;
+}
+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>;
+    /**
+    * Used to unsubscribe from observables
+    */
+    private _destroyed;
+    get destroyed(): Subject<any>;
+    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;
+}

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,29 @@
+import { Injector, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ScrollService } from '../../../core/scroll.service';
+import { HierarchyBase, HierarchyItem } from '../hierarchy-base';
+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;
+    /** 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;
+}

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

@@ -0,0 +1,28 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { CacheService } from '../../core/cache.service';
+import { ResizableBase } from './resizable-base';
+/**
+ * Make an element resizable horizontally by wrapping it in the ResizableComponent.
+ * Default widths / limits are applied but you can optionally override them
+ * with min-width and max-width with style attributes
+ * @example
+ * <ec-resizable [style.width.px]="200"
+ *               [style.min-width.px]="75"
+ *               [style.max-width.px]="300">
+ *    <div> ... </div>
+ * </ec-resizable>
+ */
+export declare class ResizableComponent extends ResizableBase implements OnInit {
+    private el;
+    constructor(el: ElementRef, renderer: Renderer2, cacheService: CacheService, document: Document);
+    /** Store the host element to reference later */
+    ngOnInit(): void;
+    /**
+     * Set the new width of the element and emit the new width to subscribers
+     */
+    protected setWidth(width: number): void;
+    /**Called from the base class when cached widths are available and restoring
+     * width is enabled. We only care about the first one because we only have one width
+     */
+    protected restoreWidths(widths: number[]): void;
+}

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

@@ -0,0 +1,51 @@
+import { EventEmitter } from '@angular/core';
+import { MenuComponent, MenuItem, MenuTemplateType } from '../../controls/menu/menu.component';
+import { HierarchyItem } from '../hierarchy/hierarchy-base';
+import { HierarchyTreeComponent } from '../hierarchy/hierarchy-tree/hierarchy-tree.component';
+import { Overlay } from '../view-overlay/view-overlay.component';
+export declare type TreeType = 'hierarchy' | 'menu';
+export declare class TreeComponent {
+    /** The value of the host elements id attribute */
+    attrId: string;
+    /**
+     * The ID of the component, bound to the host element's id attribute and passed
+     * to child components
+     */
+    set id(value: string);
+    get id(): string;
+    private _id;
+    /** The tree's title displayed in the header */
+    treeTitle: string;
+    /** Items to display in the tree when type is 'menu' */
+    treeItems?: MenuItem[];
+    /** Hide the root tree item when type is 'hierarchy' */
+    treeHierarchyHideRootNode?: boolean;
+    /** Items to display in the tree when type is 'hierarchy' */
+    treeHierarchy?: HierarchyItem;
+    /** Tree overlay */
+    status?: Overlay;
+    /** Display the tree items with a MenuComponent or a HierarchyTreeComponent */
+    type?: TreeType;
+    /** Items to display in the dropdown menu */
+    menuItems?: MenuItem[];
+    /** Tree dropdown menu overlay */
+    menuStatus?: Overlay;
+    /** The menu item template */
+    menuTemplateType?: MenuTemplateType;
+    /** Emits the item currently selected item in the tree */
+    treeSelection: EventEmitter<MenuItem | HierarchyItem>;
+    /** Emits when a hierarchy tree item is expanded as a hook to load the item's children */
+    getTreeItemChildren: EventEmitter<HierarchyItem>;
+    /** Reference to the MenuComponent instance in the template */
+    menuComponent?: MenuComponent;
+    /** Reference to the HierarchyTreeComponent instance in the template */
+    hierarchyTreeComponent?: HierarchyTreeComponent;
+    templateType: MenuTemplateType;
+    constructor();
+    /** Emits when a tree item is selected */
+    onItemSelected(item: MenuItem | HierarchyItem): void;
+    /** Emits when a hierarchy tree item is expanded to load the item's children */
+    onHierarchyGetItemChildren(item: HierarchyItem): void;
+    /** Scroll to the tree item that is currently selected. */
+    scrollToSelectedItem(): void;
+}

package/lib/shared/page/page-base/page-base.component.d.ts

@@ -7,10 +7,13 @@ import { NavItem } from '../../../controls/navigation/nav-item';
 import { ErrorService } from '../../../core/error.service';
 import { ScrollService } from '../../../core/scroll.service';
 import { DialogService } from '../../../display/dialog/dialog.service';
+import { Help } from '../../../display/help/help-types';
 import { Overlay } from '../../../display/view-overlay/view-overlay.component';
+import { PageStatus } from '../page-statuses';
 export declare class PageInitResult {
     title?: string;
     breadcrumbs?: NavItem[];
+    help?: Help;
 }
 export declare abstract class PageBaseComponent implements OnInit, AfterViewInit, OnDestroy {
     /** Default css classes applied to host element */
@@ -22,7 +25,7 @@ export declare abstract class PageBaseComponent implements OnInit, AfterViewInit
     /**
      * Status overlay for the page
      */
-    status?: Overlay;
+    status: Overlay;
     /**
      * Breadcrumbs displayed in the header
      */
@@ -31,6 +34,10 @@ export declare abstract class PageBaseComponent implements OnInit, AfterViewInit
      * Result returned from the onInit function
      */
     initResult: PageInitResult;
+    /**
+     * Help information for the component, which can only be set through onInit
+     */
+    help: Help | undefined;
     /**
      * Form group to be used if needed by the page
      */
@@ -79,6 +86,12 @@ export declare abstract class PageBaseComponent implements OnInit, AfterViewInit
      */
     private _errors;
     get errors(): string;
+    /**
+     * Optional lifecycle hook that is called as part of the Angular ngOnInit lifecycle hook.
+     * Called before onInit is called for the first time. Add setup logic here that does
+     * not need to be run on every reload.
+     */
+    protected onFirstInit(): void;
     /**
      * This method is called in the derived class as part of the Angular ngOnInit
      * lifecycle hook. It must provide a PageInitResult back to the base class to properly
@@ -96,6 +109,16 @@ export declare abstract class PageBaseComponent implements OnInit, AfterViewInit
      */
     protected onAfterViewInit(): Promise<void>;
     ngAfterViewInit(): Promise<void>;
+    /**
+     * A lifecycle method that executes once all data has been loaded
+     * through ngAfterViewInit and from local storage if required.
+     * It is at this point that you can subscribe to changes on the form
+     * reliably
+     *
+     * @protected
+     * @memberof PageBaseComponent
+     */
+    protected onFormLoadComplete(): Promise<any>;
     /**
      * A lifecycle hook that is called after every NavigationEnd event.
      */
@@ -164,6 +187,25 @@ export declare abstract class PageBaseComponent implements OnInit, AfterViewInit
      * @param unknownErrorDefault
      */
     protected getErrorMessage(e: Error | string, unknownErrorDefault?: string): Observable<string>;
+    /**
+     * Clear the errors to hide the errors banner.
+     */
+    protected hideErrorBanner(): void;
+    /**
+     * Change the display status to overlay the whole page while loading or saving
+     * and clear it when the form is ready
+     * @protected
+     * @param {PageStatus} status
+     * @memberof FormBaseComponent
+     */
+    protected showStatus(status: PageStatus): void;
+    /**
+     * Allows the component to enter a pending status and execute a function that on completion will return the status
+     * to hasData. If an error occurs within the callback an error banner can be shown.
+     * @param callback
+     * @returns
+     */
+    protected runBlockingAction(callback: () => Promise<any>, pendingMessage?: string): Promise<any>;
     /**
      * Parses the page init result and sets the necessary properties on the page
      * @param result

package/lib/shared/page/page-statuses.d.ts

@@ -0,0 +1,13 @@
+import { DisplayStatus } from '../display';
+export declare enum PageStatus {
+    Loading = "loading",
+    Loaded = "loaded",
+    Saving = "saving",
+    NoData = "noData"
+}
+export declare class PageStatuses {
+    static get loading(): DisplayStatus;
+    static get loaded(): DisplayStatus;
+    static get saving(): DisplayStatus;
+    static get noData(): DisplayStatus;
+}

package/lib/shared/testing/hierarchy-base-test-injector-factory.spec.d.ts

@@ -0,0 +1,4 @@
+import { Injector } from '@angular/core';
+export declare class HierarchyBaseTestInjectorFactory {
+    static getComponentInjector(): Injector;
+}

package/lib/shared/testing/page-base-component-test-injector-factory.spec.d.ts

@@ -12,8 +12,17 @@ export declare class PageBaseComponentTestInjectorFactory {
      * in addition to our core services
      */
     private static ComponentProviders;
+    /**
+     * Services and such retrieved by @see WizardBaseComponent via the @see Injector
+     * in addition to our core and @see PageBaseComponent services
+     */
+    private static WizardProviders;
     /**
      * Get an injector which provides spy and mock objects needed by the @see PageBaseComponent
      */
     static getComponentInjector(): Injector;
+    /**
+     * Get an injector which provides spy and mock objects needed by the @see WizardBaseComponent
+     */
+    static getWizardBaseComponentInjector(): Injector;
 }

package/lib/shared/wizard/wizard-base/wizard-base.component.d.ts

@@ -0,0 +1,131 @@
+import { Injector } from '@angular/core';
+import { NavGroup } from '../../../controls/navigation/nav-group';
+import { NavItem } from '../../../controls/navigation/nav-item';
+import { TelemetryService } from '../../../core/telemetry.service';
+import { Help } from '../../../display/help/help-types';
+import { PageBaseComponent, PageInitResult } from '../../page/page-base/page-base.component';
+export interface WizardTab extends NavItem {
+    /**
+     * Path to a form group/array/control contained in the form's main form group.
+     * Used to map a tab to it's form model for form validation in WizardBaseComponent.
+     * See https://angular.io/api/forms/AbstractControl#get-usage-notes for details on paths.
+     */
+    formModelPath?: string | (string | number)[];
+    help?: Help;
+    title?: string;
+    completed?: boolean;
+}
+export declare abstract class WizardBaseComponent extends PageBaseComponent {
+    isWizardMode: boolean;
+    showWizardSaveSuccess: boolean;
+    /** True when there are no custom fields or when in wizard mode on the custom fields tab */
+    showSave: boolean;
+    /** True when in wizard mode you do not want to show the next or save button*/
+    hideNextSaveButton: boolean;
+    /** True when in wizard mode and on the custom fields tab */
+    showBack: boolean;
+    /** Labels for the cancel, next and back buttons */
+    nextLabel?: string;
+    backLabel?: string;
+    cancelLabel: string;
+    dialogId: string;
+    /**
+     * Contains the available wizard tabs. Passed to TabsComponent.
+     * @memberof WizardBaseComponent
+     */
+    private _tabGroup;
+    get tabGroup(): NavGroup;
+    set tabGroup(value: NavGroup);
+    /**
+     * Contains the tab that is currently selected.
+     * @memberof WizardBaseComponent
+     */
+    private _currentTab?;
+    get currentTab(): WizardTab | undefined;
+    protected initPromise: Promise<WizardBaseComponent>;
+    protected telemetryService: TelemetryService;
+    constructor(injector: Injector);
+    protected onFirstInit(): void;
+    protected abstract onInit(): Promise<PageInitResult>;
+    protected onWizardSaveSuccess(): void;
+    protected onAfterViewInit(): Promise<void>;
+    protected applyModelUpdates(): Promise<void>;
+    protected saveToApi(): Promise<number | void>;
+    protected onSaveComplete(entityId: number): void;
+    onSave(event: Event): Promise<void>;
+    /**
+     * Navigates to the next tab in the tab group. Calls canGoToNextTab() to determine if navigating to the next tab
+     * is allowed or not. If tab validation succeeds, enables the next tab (if it is disabled) and selects it.
+     * @memberof WizardBaseComponent
+     */
+    nextTab(): void;
+    /**
+     * Navigates to the previous tab in the tab group. Calls canGoToPreviousTab() to determine if navigating to the previous tab
+     * is allowed or not. Navigates to the tab if validation succeeds
+     * @memberof WizardBaseComponent
+     */
+    previousTab(): void;
+    protected updateButtons(): void;
+    /**
+     * Required to configure the tabs and default tab for the wizard. Runs in onFirstInit, before onInit.
+     * @memberof WizardBaseComponent
+     */
+    protected abstract configureTabs(): NavGroup;
+    /**
+     * Used to determine whether navigation to the next tab is prevented or not. Fired in nextTab(), but not when a tab is
+     * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and
+     * prevents navigation if it is invalid. Can be overridden if different logic is needed.
+     * @param nextTab - The tab being navigated to
+     * @memberof WizardBaseComponent
+     */
+    protected canGoToNextTab(nextTab: WizardTab): boolean;
+    /**
+     * Used to determine whether navigation to the previous tab is prevented or not. Fired in previousTab(), but not when a tab is
+     * clicked or selected programmatically. By default, this checks the validity of the current tab's form model and
+     * prevents navigation if it is invalid. Can be overridden if different logic is needed.
+     * @param prevTab - The tab being navigated to
+     * @memberof WizardBaseComponent
+     */
+    protected canGoToPreviousTab(prevTab: WizardTab): boolean;
+    /**
+     * Used to determine whether navigating away from the current tab is prevented or not. Fired any time the selected tab
+     * changes in the tabGroup. By default, this checks the validity of the current tab's form model and prevents navigation
+     * if it is invalid. Can be overridden if different logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    protected canLeaveCurrentTab(): boolean;
+    /**
+     * Triggers validation on the current wizard tab's form control. Returns true if the form control is valid, false if not.
+     * Returns true if the formModelPath for the tab is not defined or no form control is found. Can be overridden if different
+     * logic is needed to validate the form control for the current tab.
+     * @memberof WizardBaseComponent
+     */
+    protected isCurrentTabValid(): boolean;
+    /**
+     * Fired if navigation to a tab succeeds. Hides the error banner by default, but can be overridden if logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    protected onTabChangeSuccess(): void;
+    /**
+     * Fired if navigation to a tab fails. By default, shows the error banner with the default invalid form message, but
+     * can be overridden if different logic is needed.
+     * @memberof WizardBaseComponent
+     */
+    protected onTabChangeFailed(): void;
+    /**
+     * Listen for when the tabGroup's selected item is changed (I.E. when a tab is clicked or selected programmatically)
+     * and navigate to that tab.
+     */
+    private subscribeToTabChanges;
+    /**
+     * Triggered when the tabGroup's selected item changes. If the current tab passes validation, updates
+     * the current tab to the selected tab.
+     * @param tab - the tab that was selected
+     */
+    private goToTab;
+    /**
+     * Updates the current tab, title, and help.
+     * @param tab Tab to set
+     */
+    private setCurrentTab;
+}

package/lib/shared/wizard/wizard-buttons/wizard-buttons.component.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from '@angular/core';
+import { DisplayStatus } from '../../display';
+export declare class WizardButtonsComponent {
+    nextLabel?: string;
+    backLabel?: string;
+    cancelLabel?: string;
+    cancelId?: string;
+    saveId?: string;
+    tabindex: number;
+    status?: DisplayStatus;
+    showBack?: boolean;
+    showSave?: boolean;
+    hideNextSaveButton?: boolean;
+    cancel: EventEmitter<any>;
+    save: EventEmitter<any>;
+    nextTab: EventEmitter<any>;
+    previousTab: EventEmitter<any>;
+    constructor();
+    onCancel(): void;
+    onSave(event: any): void;
+    onPreviousTab(): void;
+    onNextTab(): void;
+}

package/lib/shared/wizard/wizard-progress/wizard-progress.component.d.ts

@@ -0,0 +1,7 @@
+import { NavGroup } from '../../../controls/navigation/nav-group';
+import { WizardTab } from '../wizard-base/wizard-base.component';
+export declare class WizardProgressComponent {
+    tabGroup?: NavGroup;
+    currentTab?: WizardTab;
+    constructor();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@energycap/components",
-  "version": "0.26.11",
+  "version": "0.27.0",
   "dependencies": {
     "tslib": "^2.0.0"
   },