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

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

@@ -0,0 +1,67 @@
+import { Renderer2, AfterViewInit } from '@angular/core';
+import { CacheService } from '../../core/cache.service';
+import * as i0 from "@angular/core";
+export type ResizeCacheEntry = {
+    widths: number[];
+};
+/**
+ * Base class for handling click and drag resizing of elements with a mouse.
+ * Derived classes must provide the element to be resized and implement the setWidth function.
+ */
+export declare abstract class ResizableBase implements AfterViewInit {
+    protected renderer: Renderer2;
+    private cacheService;
+    protected document: Document;
+    ngAfterViewInit(): void;
+    /**Set to true if the resizable should remember its width. Requires the element to have an ID*/
+    rememberWidth: boolean;
+    /**The id of the resizable, used for GI and for remembering the width  */
+    id: string;
+    /** The element that is current being resized */
+    protected currentEl: HTMLElement | null;
+    /** The x position of the mouse when dragging starts. Relative to the viewport. */
+    protected startScreenX: number;
+    /** The width of the current element when dragging starts. */
+    protected startElWidth: number;
+    /**
+     * Stored 'unlisten' functions that remove their respective listeners when called
+     */
+    protected mouseupListener?: () => void;
+    protected mousemoveListener?: () => void;
+    constructor(renderer: Renderer2, cacheService: CacheService, document: Document);
+    /**
+     * On a mousedown event
+     * * store the width of the current element to calculate the new width
+     * * store the horizontal position of the pointer to calculate the new width.
+     * * add the 'is-active' class to the current element
+     * * set up listeners on the document to know when dragging starts and stops.
+     * Mouse event listeners are added to the document because the cursor may move
+     * off the current element while dragging.
+     */
+    startDrag(event: MouseEvent): void;
+    /**
+     * On a mousemove event, calculate the new width of the current element by
+     * adding the difference of the start pageX position and the current pageX
+     * position to the width of the element when we started dragging. Pass the
+     * calculated with to the setWidth method.
+     */
+    protected drag(event: MouseEvent): void;
+    /**
+     * Update the current element's width. Called after a mousemove event.
+     */
+    protected abstract setWidth(width: number): void;
+    /**
+     * On a mouseup event
+     * * remove the mouse event listeners on the document.
+     * * remove the 'is-active' class from the current element
+     * * reset the cursor style on the body
+     */
+    protected stopDrag(event: MouseEvent): void;
+    /**Called after the view initializes if the component supports restoring widths and there are cached widths to restore.
+     * To be overridden in a derived class if it supports restoring widths, defaults to a no-op*/
+    protected restoreWidths(widths: number[]): void;
+    /** Store the provided widths in cache so they can be retrieved later */
+    protected saveWidths(widths: number[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableBase, never, never, { "rememberWidth": { "alias": "rememberWidth"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,31 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { CacheService } from '../../core/cache.service';
+import { ResizableBase } from './resizable-base';
+import * as i0 from "@angular/core";
+/**
+ * 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "ec-resizable", never, {}, {}, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SpinnerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "ec-spinner", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,16 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { SplashService } from './splash.service';
+import * as i0 from "@angular/core";
+export declare class SplashComponent implements OnInit, OnDestroy {
+    private splashService;
+    /** Sets the visibility of the splash display */
+    isVisible: boolean;
+    stopAnimation: boolean;
+    /** Emits when the service is destroyed */
+    private destroyed;
+    constructor(splashService: SplashService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplashComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SplashComponent, "ec-splash", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SplashService {
+    /** Used to interact with the splash component
+     *  The splash component will subscribe to this and any components
+     *  that wish to bring the splash visible can use this to communicate
+     *  with the splash component.
+     */
+    private _splashVisibility;
+    splashVisibility: Observable<boolean>;
+    constructor();
+    /**
+     * Shows the splash screen
+     */
+    showSplash(): void;
+    /**
+     * Hides the splash screen
+     */
+    hideSplash(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplashService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SplashService>;
+}

package/lib/display/table/resizable-column.component.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ResizableColumnComponent {
+    el: ElementRef;
+    onResize: EventEmitter<number>;
+    constructor(el: ElementRef);
+    emitWidth(width: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableColumnComponent, "th.is-resizable", never, {}, { "onResize": "onResize"; }, never, ["*"], false, never>;
+}

package/lib/display/table/resizable-table.directive.d.ts

@@ -0,0 +1,93 @@
+import { ElementRef, OnInit, Renderer2, OnDestroy, QueryList } from '@angular/core';
+import { ResizableBase } from '../resizable/resizable-base';
+import { CacheService } from '../../core/cache.service';
+import { ResizableColumnComponent } from './resizable-column.component';
+import * as i0 from "@angular/core";
+/**
+ * Add the ability to resize columns to a standard HTML table.
+ * Specify a column as resizable by adding the .is-resizable class to a <th>.
+ *
+ * Usage:
+  ```html
+  <table [ecResizableTable]>
+    <colgroup><col><col><col></colgroup>
+    <thead>
+      <tr>
+        <th class="is-resizable">Resizable</th>
+        <th class="is-resizable">Resizable</th>
+        <th>Static</th>
+      </tr>
+    </thead>
+    ...
+  </table>
+
+  ```
+  * Note: this directive is meant to be used internally with the TableComponent
+  * and is not exposed in the public-api of the library
+ */
+export declare class ResizableTableDirective extends ResizableBase implements OnInit, OnDestroy {
+    private el;
+    isResizable: boolean | undefined;
+    containerEl: ElementRef;
+    sortableTable: boolean;
+    /**
+     * Used to notify the resizable directive that the columns are ready to be configured.
+     * Must be used if the number of columns can change over the table's lifecycle.
+     */
+    resizableColumns: QueryList<ResizableColumnComponent>;
+    /** The host <table> element. Will throw if host element is not a <table> */
+    private tableEl;
+    /**
+     * Stored reference to the <col> element children. Will throw if none are found. Will
+     * warn if the number of <col> elements do not match the number of <th> elements
+     */
+    private cols;
+    /**
+     * The widths of each table column. These are updated as columns are resized and
+     * are used to calculate the new table width.
+     */
+    private colWidths;
+    /**
+     * The current table width
+     */
+    private currentTableWidth;
+    /**
+     * The width of the table when the component was initialized. The table cannot
+     * be shrunk below this width. If a column resize would cause the current table
+     * width to be below this value, the last column is widened instead.
+     */
+    private minTableWidth;
+    /**
+     * The width the column can not be resized below.
+     */
+    private minColWidth;
+    private lastColIndex;
+    private destroyed;
+    constructor(el: ElementRef, renderer: Renderer2, cacheService: CacheService, document: Document);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Initialize
+     * * Check that the host element is a table and that <col> elements are present
+     * * Save the initial width of table as the minimum table width
+     * * Store a reference to all <col> elements
+     * * Add a handle to each resizable column and set up mousedown listeners to start dragging
+     */
+    private initResizableColumns;
+    /**
+     * Update the column with the calculated width while resizing.
+     * If the column is narrowed so that the table would be narrower than the min-width,
+     * expand the last column. If the table is then widened, return the last column
+     * to its initial width.
+     * @param width
+     */
+    protected setWidth(width: number): void;
+    protected stopDrag(event: MouseEvent): void;
+    /**
+     * Capture the initial width of the table and the table headers.
+     * @param headers
+     */
+    private setInitialWidths;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableTableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableTableDirective, "[ecResizableTable]", never, { "isResizable": { "alias": "ecResizableTable"; "required": false; }; "containerEl": { "alias": "containerEl"; "required": false; }; "sortableTable": { "alias": "sortableTable"; "required": false; }; "resizableColumns": { "alias": "resizableColumns"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/display/table/searchable-table.component.d.ts

@@ -0,0 +1,206 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
+import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ErrorService } from '../../core/error.service';
+import { RowCountPipe } from '../../shared/display/pipes/row-count.pipe';
+import { Overlay } from '../view-overlay/view-overlay.component';
+import { ResizableColumnComponent } from './resizable-column.component';
+import { PagingInfo } from './table-pagination.component';
+import { TableSelectableRowContext } from './table-selectable-row.component';
+import { TableSort } from './table.component';
+import * as i0 from "@angular/core";
+export type TableSearchResults = {
+    items: unknown[];
+    totalItems: number;
+    totalItemsBeforePaging?: number;
+};
+export type SearchableTableRefreshOptions = {
+    clearSearch?: boolean;
+};
+export declare class SearchableTableComponent implements OnInit, OnDestroy, OnChanges {
+    private errorService;
+    private translateService;
+    private rowCountPipe;
+    id: string;
+    resizable: boolean;
+    sortable: boolean;
+    sort?: TableSort | TableSort[];
+    autofocus: boolean;
+    /**Set to a space-separated set of strings that should be added to the ec-table class attribute
+     * this allows finer control over styling.
+     */
+    tableClasses: string;
+    /** Emits when table sort has changed */
+    sortChange: EventEmitter<TableSort | TableSort[]>;
+    /** Emits when the table page has changed */
+    pageChangeEmitter: EventEmitter<PagingInfo>;
+    /** Placeholder text for the searchbox */
+    searchboxPlaceholder: string;
+    /**
+     * FormGroup for the searchbox
+     *
+     * The referenced FormGroup **must** contain a FormControl called 'searchModel'.
+     */
+    formModel: UntypedFormGroup;
+    /**
+     * Displayed in overlay when no data is returned (without searching).
+     *
+     * Defaults to "SearchableTable_Default_NoData_SC"
+     */
+    noDataMessage: string;
+    /**
+     * Displayed in overlay when no data is returned (after searching).
+     * Ensure translation has an interpolation placeholder for "searchText".
+     *
+     * Defaults to "SearchableTable_Default_NoMatches_SC"
+     *
+     * @example
+     * // 7 requires single curly braces
+     * No items found matching <strong>{{searchText}}</strong>
+     */
+    noSearchResultsMessage: string;
+    /**
+     * Indicates hosting page is ready for the table to load data.
+     *
+     * Next and Complete this observable after hosting page has made any preliminary
+     * API (or other asynchronous) calls to load prerequisite data upon which the code
+     * in the `getItems` function depends.  Use a `ReplaySubject` to ensure every component
+     * that uses this observable gets the Next and Complete notifications.
+     */
+    ready: Observable<void>;
+    /**
+     * Function called to get items to display in the table.
+     * If pageable is true, the TableSearchResults need to include totalItemsBeforePaging, which is the
+     * count of items before you've applied any pagination (i.e. the total number of items that came back from the search).
+     *
+     * Make sure to bind the scope in the template
+     * @example
+     * [getItems]="yourFunction.bind(this)"
+     */
+    getItems: (search?: string, pageChangeInfo?: PagingInfo) => Observable<TableSearchResults>;
+    /** Observable that will force the getItems function to get called again */
+    refresh?: Observable<SearchableTableRefreshOptions | void>;
+    /** Allow the host component to supply an overlay to control the pending state of the table */
+    status: Overlay;
+    /**
+     * Sets the underlying table's layout to fixed.
+     */
+    tableLayoutFixed: boolean;
+    /** Emits items returned by the getItems function, along with total count */
+    itemsChange: EventEmitter<TableSearchResults>;
+    /** Optional tab index for the searchbox */
+    searchboxTabIndex?: number;
+    /** Maximum number of items to show in the table (default: 100) */
+    maxItemCount: number;
+    /** Set to true to hide search box (does not hide the other searchable table controls */
+    hideSearchControl: boolean;
+    /** Set to true to hide the entire header */
+    hideHeader: boolean;
+    /** Type of object in the table. Displayed in footer (default: 'results')*/
+    objectType: string;
+    /** Set to true to hide the table footer */
+    hideFooter: boolean;
+    /**
+     * Set to true to enable paging. If paging is enabled, pageSize must be provided.
+     * getItems will be passed both a search and a PagingInfo object when called. It must include totalItemsBeforePaging in the TableSearchResults output.
+     * Here is a simple implementation:
+     * @example
+     * getItems(search?: string, pageChangeInfo?: PagingInfo): Observable<TableSearchResults> {
+        let results: SimpleItem[] = [...this.paginatedTableItems];
+        //apply search
+        if(search) {
+          results = this.paginatedTableItems.filter(i => i.a.toLowerCase().includes(search.toLowerCase()));
+        }
+        //get count before applying paging
+        let countBeforePaging = results.length;
+        //apply paging
+        if(pageChangeInfo) {
+          results = results.slice(pageChangeInfo!.skip, pageChangeInfo!.skip + pageChangeInfo!.pageSize);
+        }
+        return of({ items: results, totalItems: results.length, totalItemsBeforePaging: countBeforePaging });
+      }
+    */
+    pageable: boolean;
+    /**
+     * Max size of a page.
+     */
+    pageSize?: number;
+    /**
+   * Maximum number of page tabs to show
+   */
+    maxTabs?: number;
+    /**
+     * Makes the searchbox readonly if true.
+     */
+    searchboxReadonly: boolean;
+    /** Passed to the inner TableComponent to enable row selection */
+    selectionContext?: TableSelectableRowContext;
+    /** Passed to the inner TableComponent to display a toolbar when 1 or more rows are selected. Requires `[selectionContext]` to be defined. */
+    selectionToolbarTemplate?: TemplateRef<any>;
+    resizableColumns: QueryList<ResizableColumnComponent>;
+    /** Optional text to add to the results count in the table footer. This text will be added after the count and objectType. */
+    additionalCountText: string;
+    /** Enables table row selection and row highlighting styles when true */
+    selectable: boolean;
+    /**Defaults to undefined. Specify your own template if an ec-table wrapped around your transcluded content won't meet your needs
+     */
+    customContentTemplate?: TemplateRef<any>;
+    /** When true, removes the card styles from the table wrapper */
+    removeCard: boolean;
+    /** Classes to add to the overlay/card element */
+    overlayClasses: string;
+    /** When true the overlay and table will not have flex-shrink-max but instead flex-grow */
+    fillParentHeight?: boolean;
+    /** Passed to the pagination control component. Used to disable the pagination controls */
+    disablePaginationControls?: boolean;
+    /**
+     * PagingInfo for the current page.
+     */
+    pageInfo?: PagingInfo;
+    /** Reference to the searchModel */
+    get searchModel(): UntypedFormControl;
+    /**
+     * Text displayed in the footer.
+     * Sometimes `noDataMessage`, sometimes `noSearchResultsMessage`
+     */
+    tableCaption: string;
+    /** count of results displayed in the table */
+    resultsCount: string;
+    /** Items returned by the getItems function, along with total count */
+    searchResults: TableSearchResults;
+    /**
+     * If passed an input for refresh, triggers reloading items.
+     * Otherwise, completes immediately (will never trigger reload).
+     */
+    private refreshTrigger;
+    private destroyed;
+    private pageChanged;
+    /** Triggers the initial load of the table */
+    private initTable;
+    constructor(errorService: ErrorService, translateService: TranslateService, rowCountPipe: RowCountPipe);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Pass along sort to parent component */
+    onSortChange(sort: TableSort | TableSort[]): void;
+    /**
+     * When a page changes, store the new pagingInfo and emit the current value of the form to trigger getData.
+     */
+    onPageChange(pagingInfo: PagingInfo): void;
+    /**
+     * Wire up a handler to the `refresh` observable so that when
+     * the host page context changes it can force the table to update as well.
+     *
+     * If the `refresh` observable passes options and the `clearSearch` property
+     * is set to true, reset the searchModel and pass an empty string.
+     *
+     * If `refresh` observable does not pass options or the `clearSearch` property
+     * is set to false, pass along the current searchModel Value.
+     */
+    private setUpRefreshTrigger;
+    /** Get text to display in the footer. */
+    private getCaption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchableTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchableTableComponent, "ec-searchable-table", never, { "id": { "alias": "id"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "tableClasses": { "alias": "tableClasses"; "required": false; }; "searchboxPlaceholder": { "alias": "searchboxPlaceholder"; "required": false; }; "formModel": { "alias": "formModel"; "required": false; }; "noDataMessage": { "alias": "noDataMessage"; "required": false; }; "noSearchResultsMessage": { "alias": "noSearchResultsMessage"; "required": false; }; "ready": { "alias": "ready"; "required": false; }; "getItems": { "alias": "getItems"; "required": false; }; "refresh": { "alias": "refresh"; "required": false; }; "status": { "alias": "status"; "required": false; }; "tableLayoutFixed": { "alias": "tableLayoutFixed"; "required": false; }; "searchboxTabIndex": { "alias": "searchboxTabIndex"; "required": false; }; "maxItemCount": { "alias": "maxItemCount"; "required": false; }; "hideSearchControl": { "alias": "hideSearchControl"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "objectType": { "alias": "objectType"; "required": false; }; "hideFooter": { "alias": "hideFooter"; "required": false; }; "pageable": { "alias": "pageable"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "maxTabs": { "alias": "maxTabs"; "required": false; }; "searchboxReadonly": { "alias": "searchboxReadonly"; "required": false; }; "selectionContext": { "alias": "selectionContext"; "required": false; }; "selectionToolbarTemplate": { "alias": "selectionToolbarTemplate"; "required": false; }; "additionalCountText": { "alias": "additionalCountText"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "customContentTemplate": { "alias": "customContentTemplate"; "required": false; }; "removeCard": { "alias": "removeCard"; "required": false; }; "overlayClasses": { "alias": "overlayClasses"; "required": false; }; "fillParentHeight": { "alias": "fillParentHeight"; "required": false; }; "disablePaginationControls": { "alias": "disablePaginationControls"; "required": false; }; }, { "sortChange": "sortChange"; "pageChangeEmitter": "pageChange"; "itemsChange": "itemsChange"; }, ["resizableColumns"], [".searchable-table-controls", ".card-header", "*", ".searchable-table-footer"], false, never>;
+}

package/lib/display/table/table-detail-row.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class TableDetailRowComponent {
+    contentClass?: string;
+    contentColSpan: number;
+    maxHeight?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDetailRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableDetailRowComponent, "[ecTableDetailRow]", never, { "contentClass": { "alias": "contentClass"; "required": false; }; "contentColSpan": { "alias": "contentColSpan"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/display/table/table-locked-column.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit, ElementRef, OnChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TableLockedColumnComponent implements OnInit, OnChanges {
+    private el;
+    options: {
+        border: boolean;
+        left?: number;
+        right?: number;
+    };
+    left?: number;
+    right?: number;
+    borderRight: boolean;
+    borderLeft: boolean;
+    constructor(el: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private updatePositionAndBorder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableLockedColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableLockedColumnComponent, "[ecTableLockedColumn]", never, { "options": { "alias": "ecTableLockedColumn"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/display/table/table-master-header-row.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class TableMasterHeaderRowComponent {
+    /** Used to hide the header added to the table. Useful if a table is shared between views and not all
+     *  support the table master scenario
+     */
+    hideTableMaster?: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableMasterHeaderRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableMasterHeaderRowComponent, "[ecTableMasterHeaderRow]", never, { "hideTableMaster": { "alias": "hideTableMaster"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/display/table/table-master-row.component.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter, TemplateRef, ElementRef, Renderer2, SimpleChanges, OnChanges, OnDestroy, OnInit, ApplicationRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TableMasterRowComponent implements OnChanges, OnInit, OnDestroy {
+    private renderer;
+    private el;
+    private appRef;
+    /**
+     * Identifier to pass to the collapsible toggle
+     */
+    id?: string;
+    /**
+     * Controls whether the table row has details and shows the collapsible toggle if it does.
+     */
+    hasDetails?: boolean;
+    /**
+     * Programmatically toggle the visibility of the detail row. Default is false.
+     */
+    showDetails: boolean;
+    /**
+     * Template for the detail row content. Generates an [EmbeddedViewRef](https://angular.io/api/core/EmbeddedViewRef)
+     * with the 'detailContext'. Required if hasDetails is true.
+     */
+    detailTemplate: TemplateRef<any>;
+    /**
+     * Optional context bound to the 'detailTemplate'. Available in the template as the default local template `let` declaration.
+     * @example
+     * ```html
+     * <tr *ngFor="let item of items" ecTableMasterRow [detailTemplate]="myDetailTemplate" [detailContext]="item">
+     *  ...
+     * </tr>
+     *
+     * <ng-template #myDetailTemplate let-item>
+     *  <p>{{item.comment}}</p>
+     * </ng-template>
+     */
+    detailContext?: any;
+    /**
+     * The number of columns in your table minus the column that is automatically added by the
+     * TableMasterRowComponent. Required.
+     */
+    detailRowColSpan: number;
+    /**
+     * Space delimited string added to the class attribute of detail row TR.
+     */
+    detailRowClass?: string;
+    /**
+     * Space delimited string added to the class attribute of the TD that contains the detail row content
+     */
+    detailRowContentClass?: string;
+    detailRowMaxHeight?: string;
+    /** Space delimited string added to the class attribute of the TD that contains the collapsible toggle
+     *  element.
+     */
+    collapsibleToggleCellClass?: string;
+    /** Used to hide the cell added to the table. Useful if a table is shared between views and not all
+     *  support the table master scenario
+     */
+    hideTableMaster?: boolean;
+    /**
+     * Emits an event when the value of `showDetails` changes.
+     */
+    showDetailsChanged: EventEmitter<boolean>;
+    /**
+     * The template for the detail row, inserted in the DOM after the master row.
+     */
+    detailRowTemplate: TemplateRef<any>;
+    /**
+     * The view created from the `detailRow` template.
+     */
+    private detailView?;
+    /**
+     * The parent node of the host element.
+     */
+    private parentNode;
+    /**
+     * The sibling node of the host element.
+     */
+    private siblingNode;
+    constructor(renderer: Renderer2, el: ElementRef, appRef: ApplicationRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * When the master row has details, create the detail row and update it's visibility. If the master
+     * has no details, remove the detail row
+     */
+    updateDetailRow(): void;
+    /**
+     * Show/hide the detail row
+     */
+    toggleDetails(show: boolean): void;
+    private updateVisibility;
+    /**
+     * Attach the detailView the change detection tree and insert the generated html
+     * of the detail row to DOM after the host element
+     */
+    private show;
+    /**
+     * Detach the detailView from the change detection tree and remove the generated
+     * html of the detail row from the DOM
+     */
+    private hide;
+    /**
+     * Destroy the detailView and remove the generated html of the detail row from the DOM
+     */
+    private removeDetailView;
+    /**
+     * Remove the generated html of the detail row from the DOM
+     */
+    private removeDetailNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableMasterRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableMasterRowComponent, "[ecTableMasterRow]", never, { "id": { "alias": "id"; "required": false; }; "hasDetails": { "alias": "hasDetails"; "required": false; }; "showDetails": { "alias": "showDetails"; "required": false; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; }; "detailContext": { "alias": "detailContext"; "required": false; }; "detailRowColSpan": { "alias": "detailRowColSpan"; "required": false; }; "detailRowClass": { "alias": "detailRowClass"; "required": false; }; "detailRowContentClass": { "alias": "detailRowContentClass"; "required": false; }; "detailRowMaxHeight": { "alias": "detailRowMaxHeight"; "required": false; }; "collapsibleToggleCellClass": { "alias": "collapsibleToggleCellClass"; "required": false; }; "hideTableMaster": { "alias": "hideTableMaster"; "required": false; }; }, { "showDetailsChanged": "showDetailsChanged"; }, never, ["*"], false, never>;
+}