@colijnit/corecomponents_v12 12.2.21 → 12.2.23

package/lib/components/input-textarea/input-textarea.component.d.ts

@@ -0,0 +1,19 @@
+import { AfterViewInit, ChangeDetectorRef, ComponentFactoryResolver, ElementRef } from '@angular/core';
+import { BaseInputComponent } from '../base/base-input.component';
+import { FormInputUserModelChangeListenerService } from '../../core/service/form-input-user-change-listener.service';
+import { NgZoneWrapperService } from '../../core/service/ng-zone-wrapper.service';
+import { FormComponent } from '../form/form.component';
+import { OverlayService } from '../../service/overlay.service';
+export declare class InputTextareaComponent extends BaseInputComponent<any> implements AfterViewInit {
+    formComponent: FormComponent;
+    protected changeDetector: ChangeDetectorRef;
+    protected overlayService: OverlayService;
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected formUserChangeListener?: FormInputUserModelChangeListenerService;
+    protected ngZoneWrapper?: NgZoneWrapperService;
+    elementRef?: ElementRef;
+    placeholder: string;
+    showClass(): boolean;
+    hasOwnLabel: boolean;
+    constructor(formComponent: FormComponent, changeDetector: ChangeDetectorRef, overlayService: OverlayService, componentFactoryResolver: ComponentFactoryResolver, formUserChangeListener?: FormInputUserModelChangeListenerService, ngZoneWrapper?: NgZoneWrapperService, elementRef?: ElementRef);
+}

package/lib/components/input-textarea/input-textarea.module.d.ts

@@ -0,0 +1,2 @@
+export declare class InputTextareaModule {
+}

package/lib/components/level-indicator/level-indicator-level.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum LevelIndicatorLevel {
+    Low = "low",
+    Medium = "medium",
+    High = "high"
+}

package/lib/components/level-indicator/level-indicator.component.d.ts

@@ -0,0 +1,10 @@
+import { LevelIndicatorLevel } from './level-indicator-level.enum';
+export declare class LevelIndicatorComponent {
+    set model(value: LevelIndicatorLevel);
+    get model(): LevelIndicatorLevel;
+    showClass: boolean;
+    get modelAsString(): string;
+    private _model;
+    private _modelAsString;
+    constructor();
+}

package/lib/components/level-indicator/level-indicator.module.d.ts

@@ -0,0 +1,2 @@
+export declare class LevelIndicatorModule {
+}

package/lib/components/list-of-values/list-of-values-multiselect-popup.component.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { BaseInputComponent } from "../base/base-input.component";
+import { CoreComponentsIcon } from "../../core/enum/core-components-icon.enum";
+export declare class ListOfValuesMultiselectPopupComponent extends BaseInputComponent<any> implements OnInit {
+    readonly icons: typeof CoreComponentsIcon;
+    showClass(): boolean;
+    chosenCollection: EventEmitter<any[]>;
+    closePopup: EventEmitter<any>;
+    returnChosenCollection: any[];
+    parentForOverlay: ElementRef;
+    displayField: string;
+    set collection(value: any[]);
+    get collection(): any[];
+    selectedCollection: any[];
+    selectedOptions: any[];
+    allOptionsSelected: boolean;
+    searchTerm: string;
+    private _collection;
+    get filteredCollection(): any;
+    ngOnInit(): void;
+    onOptionClick(option: any): void;
+    okClicked(): void;
+    onToggleSelectAll(): void;
+    searchCollection(): void;
+}

package/lib/components/list-of-values/list-of-values-popup.component.d.ts

@@ -0,0 +1,47 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { InputSearchComponent } from '../input-search/input-search.component';
+export interface lovViewModel {
+    checked: boolean;
+    model: any;
+}
+export declare class ListOfValuesPopupComponent implements OnInit {
+    private _elementRef;
+    set lovItems(children: any);
+    dropDownList: ElementRef;
+    set inputSearch(component: InputSearchComponent);
+    model: any;
+    multiselect: boolean;
+    displayField: string;
+    searchPlaceholder: string;
+    customCssClass: string;
+    searchDisabled: boolean;
+    parentForOverlay: ElementRef;
+    set collection(value: any[]);
+    get collection(): any[];
+    modelChange: EventEmitter<any>;
+    closePopup: EventEmitter<Event>;
+    keyDown: EventEmitter<KeyboardEvent>;
+    showClass(): boolean;
+    set searchTerm(value: string);
+    get searchTerm(): string;
+    viewModels: lovViewModel[];
+    viewModelsMain: lovViewModel[];
+    highLightModel: lovViewModel;
+    private _collection;
+    private _searchTerm;
+    private _lovItems;
+    private _searchInput;
+    constructor(_elementRef: ElementRef);
+    ngOnInit(): void;
+    handleInputKeyDown(event: KeyboardEvent): boolean;
+    filterViewModels(): void;
+    selectViewModel(viewModel: lovViewModel, closePopup?: boolean): void;
+    selectModelByViewModel(viewModel: lovViewModel, closePopup?: boolean): void;
+    selectOptionAndClosePopup(): void;
+    selectOptions(): void;
+    selectNextOption(back?: boolean): void;
+    private _prepareViewModelsMain;
+    private _prepareViewModels;
+    private _scrollIntoView;
+    private _scrollActiveItemIntoView;
+}

package/lib/components/list-of-values/list-of-values.component.d.ts

@@ -0,0 +1,37 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { BaseInputComponent } from '../base/base-input.component';
+import { CoreComponentsIcon } from '../../core/enum/core-components-icon.enum';
+import { SafeHtml } from '@angular/platform-browser';
+export declare class ListOfValuesComponent extends BaseInputComponent<any> implements OnInit {
+    readonly icons: typeof CoreComponentsIcon;
+    set model(value: any);
+    get model(): any;
+    parentForOverlay: ElementRef;
+    multiselect: boolean;
+    displayField: string;
+    set collection(value: any[]);
+    get collection(): any[];
+    leftIconData: SafeHtml | undefined;
+    searchPlaceholder: string;
+    label: string;
+    customCssClass: string;
+    searchDisabled: boolean;
+    showClass(): boolean;
+    isSelectOpen: boolean;
+    state: string;
+    selectedModel: string;
+    selectedModels: string[];
+    private _collection;
+    private _lovPopupComponentRef;
+    ngOnInit(): void;
+    handleInputModelChange(model: string): void;
+    handleInputKeyDown(event: KeyboardEvent): boolean;
+    clearModel(event: MouseEvent): void;
+    toggleSelect(): void;
+    openPopup(): void;
+    removeOptionFromModel(chip: any): void;
+    optionChosen(option: any): void;
+    closePopup(): void;
+    checkModel(): void;
+    private _setSelectedModel;
+}

package/lib/components/list-of-values/list-of-values.module.d.ts

@@ -0,0 +1,2 @@
+export declare class ListOfValuesModule {
+}

package/lib/components/loader/loader.component.d.ts

@@ -0,0 +1,3 @@
+export declare class LoaderComponent {
+    showClass(): boolean;
+}

package/lib/components/loader/loader.module.d.ts

@@ -0,0 +1,2 @@
+export declare class LoaderModule {
+}

package/lib/components/pagination/paginate.pipe.d.ts

@@ -0,0 +1,15 @@
+import { PipeTransform } from "@angular/core";
+export declare class PaginatePipe implements PipeTransform {
+    private state;
+    transform(collection: any[], args: any): any;
+    private _createInstance;
+    private _checkConfig;
+    /**
+     * To avoid returning a brand new array each time the pipe is run, we store the state of the sliced
+     * array for a given id. This means that the next time the pipe is run on this collection & id, we just
+     * need to check that the collection, start and end points are all identical, and if so, return the
+     * last sliced array.
+     */
+    private _saveState;
+    private _stateIsIdentical;
+}

package/lib/components/pagination/pagination-instance.d.ts

@@ -0,0 +1,14 @@
+export interface IPaginationInstance {
+    id?: string;
+    itemsPerPage: number;
+    currentPage: number;
+    /**
+     * The total number of items in the collection. Only useful when
+     * doing server-side paging, where the collection size is limited
+     * to a single page returned by the server API.
+     *
+     * For in-memory paging, this property should not be set, as it
+     * will be automatically set to the value of  collection.length.
+     */
+    totalItems?: number;
+}

package/lib/components/pagination/pagination.component.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { PaginationService } from './pagination.service';
+export declare class PaginationComponent implements OnInit, OnChanges, OnDestroy {
+    private _paginationService;
+    readonly template: ElementRef;
+    id: string;
+    maxSize: number;
+    directionLinks: boolean;
+    previousLabel: string;
+    nextLabel: string;
+    autoHide: boolean;
+    readonly pageChange: EventEmitter<number>;
+    showClass: boolean;
+    totalItems: number;
+    itemsPerPage: number;
+    private changeSub;
+    constructor(_paginationService: PaginationService);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    goToFirstPage(): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    setCurrentPage(page: number): void;
+    shouldBeHidden(): boolean;
+    /**
+     * Updates the page links and checks that the current page is valid. Should run whenever the
+     * PaginationService.change stream emits a value matching the current ID, or when any of the
+     * input values changes.
+     */
+    private _updatePageLinks;
+    getCurrentPage(): number;
+    /**
+     * Checks that the instance.currentPage property is within bounds for the current page range.
+     * If not, return a correct value for currentPage, or the current value if OK.
+     */
+    private outOfBoundCorrection;
+}

package/lib/components/pagination/pagination.module.d.ts

@@ -0,0 +1,2 @@
+export declare class PaginationModule {
+}

package/lib/components/pagination/pagination.service.d.ts

@@ -0,0 +1,24 @@
+import { Subject } from "rxjs";
+import { IPaginationInstance } from "./pagination-instance";
+export declare class PaginationService {
+    private static readonly DEFAULT_ID;
+    change: Subject<string>;
+    get DEFAULT_ID(): string;
+    private readonly instances;
+    constructor();
+    register(instance: IPaginationInstance): void;
+    getCurrentPage(id: string): number;
+    setCurrentPage(id: string, page: number): void;
+    setTotalItems(id: string, totalItems: number): void;
+    setItemsPerPage(id: string, itemsPerPage: number): void;
+    /**
+     * Returns a clone of the pagination instance object matching the id. If no
+     * id specified, returns the instance corresponding to the default id.
+     */
+    getInstance(id?: string): IPaginationInstance;
+    /**
+     * Check each property of the instance and update any that have changed. Return
+     * true if any changes were made, else return false.
+     */
+    private updateInstance;
+}

package/lib/components/pagination-bar/pagination-bar.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from "@angular/core";
+export interface IPage {
+    label: string;
+    value: any;
+}
+export declare class PaginationBarComponent implements OnInit, OnChanges {
+    directionLinks: boolean;
+    previousLabel: string;
+    nextLabel: string;
+    currentPage: number;
+    itemsPerPage: number;
+    set totalItems(value: number);
+    get totalItems(): number;
+    paginationRange: number;
+    autoHide: boolean;
+    previousClick: EventEmitter<void>;
+    nextClick: EventEmitter<void>;
+    pageClick: EventEmitter<any>;
+    showClass(): boolean;
+    private _totalItems;
+    pages: IPage[];
+    totalPages: number;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    isOnFirstPage(): boolean;
+    isOnLastPage(): boolean;
+    onPreviousClick(): void;
+    onNextClick(): void;
+    onPageClick(value: any): void;
+    shouldBeHidden(): boolean;
+    private _createPageArray;
+    private _calculatePageNumber;
+}

package/lib/components/pagination-bar/pagination-bar.module.d.ts

@@ -0,0 +1,2 @@
+export declare class PaginationBarModule {
+}

package/lib/components/popup/const/popup-window-token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { PopupWindowModel } from '../model/popup-window';
+export declare const POPUP_WINDOW_DATA: InjectionToken<PopupWindowModel>;

package/lib/components/popup/interface/popup-button.d.ts

@@ -0,0 +1,8 @@
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+export declare class PopupButton {
+    label: string;
+    cssClass: string;
+    closeType: PopupButtonType;
+    disabled: boolean;
+    constructor(label: string, cssClass: string, closeType: PopupButtonType);
+}

package/lib/components/popup/interface/popup-close-event.d.ts

@@ -0,0 +1,5 @@
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+export interface PopupCloseEvent<T = any> {
+    eventType: PopupButtonType;
+    output: T;
+}

package/lib/components/popup/interface/popup-settings.d.ts

@@ -0,0 +1,21 @@
+import { PopupButton } from './popup-button';
+import { PopupType } from '../../../core/enum/popup-type.enum';
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+export declare class PopupSettings {
+    title: string;
+    autoClose: boolean;
+    type: PopupType;
+    buttons?: PopupButton[];
+    hideCloseIcon?: boolean;
+    noButtonFocus?: boolean;
+    fixed?: boolean;
+    downloadable?: boolean;
+    constructor();
+    enableButtonByType(buttonType: PopupButtonType): void;
+    disableButtonByType(buttonType: PopupButtonType): void;
+    enableSaveButton(): void;
+    disableSaveButton(): void;
+    enableOpenButton(): void;
+    disableOpenButton(): void;
+    private _getButtonByType;
+}

package/lib/components/popup/interface/popup.d.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from "@angular/core";
+import { PopupWindowModel } from '../model/popup-window';
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+export interface Popup<T = any> {
+    readonly closeRequest?: EventEmitter<PopupButtonType>;
+    popupModel?: PopupWindowModel;
+    onOpen?(): void;
+    onClose(eventType: PopupButtonType): Promise<T>;
+}

package/lib/components/popup/model/popup-button-globals.d.ts

@@ -0,0 +1,9 @@
+import { PopupButton } from '../interface/popup-button';
+export declare class PopupButtonGlobals {
+    static readonly Ok: PopupButton;
+    static readonly Open: PopupButton;
+    static readonly Save: PopupButton;
+    static readonly Cancel: PopupButton;
+    static readonly Yes: PopupButton;
+    static readonly No: PopupButton;
+}

package/lib/components/popup/model/popup-window.d.ts

@@ -0,0 +1,21 @@
+import { ComponentFactory } from "@angular/core";
+import { PopupType } from '../../../core/enum/popup-type.enum';
+import { PopupWindowShellComponent } from '../popup-window-shell.component';
+import { PopupButtonType } from '../../../core/enum/popup-button-type.enum';
+import { Popup } from '../interface/popup';
+import { PopupSettings } from '../interface/popup-settings';
+export declare class PopupWindowModel {
+    factory: ComponentFactory<Popup>;
+    settings: PopupSettings;
+    inputs: any;
+    static readonly closeDefaultOutputStr: string;
+    get type(): PopupType;
+    uuid: string;
+    popupWindowComponent?: PopupWindowShellComponent;
+    constructor(factory: ComponentFactory<Popup>, settings: PopupSettings, inputs: any);
+    closeDefault(): void;
+    enableOpenButton(): void;
+    disableOpenButton(): void;
+    getTitle(): string;
+    onClose(eventType: PopupButtonType, output?: any): void;
+}

package/lib/components/popup/popup-buttons.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter, OnInit } from "@angular/core";
+import { ButtonComponent } from "../button/button.component";
+import { PopupButton } from "./interface/popup-button";
+export declare class PopupButtonsComponent implements OnInit {
+    popupWindow: any;
+    readonly buttonClick: EventEmitter<PopupButton>;
+    firstButton: ButtonComponent;
+    buttons: PopupButton[];
+    constructor();
+    ngOnInit(): void;
+    handleClick(event: MouseEvent, button: PopupButton): void;
+    focusFirstButton(): void;
+}

package/lib/components/popup/popup-message-display.component.d.ts

@@ -0,0 +1,12 @@
+import { PopupButtonType } from '../../core/enum/popup-button-type.enum';
+import { Popup } from './interface/popup';
+export declare class PopupMessageDisplayComponent implements Popup<PopupButtonType> {
+    set message(value: string);
+    get message(): string;
+    details: string;
+    image: boolean;
+    private _message;
+    constructor();
+    onClose(eventType: PopupButtonType): Promise<PopupButtonType>;
+    handleCopyClick(): void;
+}

package/lib/components/popup/popup-window-shell.component.d.ts

@@ -0,0 +1,42 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, OnInit, ViewContainerRef } from "@angular/core";
+import { PopupButtonsComponent } from "./popup-buttons.component";
+import { PopupButtonType } from "../../core/enum/popup-button-type.enum";
+import { PopupWindowModel } from "./model/popup-window";
+import { PopupButton } from "./interface/popup-button";
+import { CoreComponentsIcon } from "../../core/enum/core-components-icon.enum";
+import { IconCacheService } from "../icon/icon-cache.service";
+import { SafeHtml } from "@angular/platform-browser";
+export declare class PopupWindowShellComponent implements AfterViewInit, OnDestroy, OnInit {
+    private _iconCache;
+    private _changeDetector;
+    viewContainerRef: ViewContainerRef;
+    readonly icons: typeof CoreComponentsIcon;
+    popupWindow: PopupWindowModel;
+    hasMobileSizings: boolean;
+    protected _viewContainer: ViewContainerRef;
+    protected _appPopupButtons: PopupButtonsComponent;
+    isError: boolean;
+    isWarning: boolean;
+    isNotification: boolean;
+    isQuestion: boolean;
+    isMovable: boolean;
+    isBlank: boolean;
+    closeIcon: SafeHtml;
+    downloadIcon: SafeHtml;
+    private _popupCompRef;
+    private _filterClickSub;
+    private _popupCloseRequestSub;
+    constructor(_iconCache: IconCacheService, _changeDetector: ChangeDetectorRef, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(eventType: PopupButtonType): Promise<void>;
+    onButtonClick(button: PopupButton): void;
+    onDownloadClick(): void;
+    onCloseClick(): void;
+    private _close;
+    private _createPopupComponent;
+    private _initOnClickAutoClose;
+    private _initAppPopupCloseRequestHandler;
+    private _setHostBindings;
+}

package/lib/components/popup/popup.module.d.ts

@@ -0,0 +1,4 @@
+import { ModuleWithProviders } from '@angular/core';
+export declare class PopupModule {
+    static forRoot(): ModuleWithProviders<PopupModule>;
+}

package/lib/components/popup/service/popup-shower.service.d.ts

@@ -0,0 +1,17 @@
+import { ApplicationRef, ComponentFactoryResolver, Injector } from "@angular/core";
+import { PopupSettings } from '../interface/popup-settings';
+import { PopupCloseEvent } from '../interface/popup-close-event';
+import { Overlay } from '@angular/cdk/overlay';
+export declare class PopupShowerService {
+    private _compFactoryResolver;
+    private _appRef;
+    private _overlay;
+    private _injector;
+    constructor(_compFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _overlay: Overlay, _injector: Injector);
+    showPopup<T = any>(popupCompClazz: any, popupSettings: PopupSettings, inputs?: any): Promise<PopupCloseEvent<T>>;
+    private _createWindowShell;
+    private _createOverlay;
+    private _getConfig;
+    private _attachDialogContainer;
+    private _createInjector;
+}

package/lib/components/popup/service/prompt.service.d.ts

@@ -0,0 +1,17 @@
+import { PopupShowerService } from './popup-shower.service';
+import { StringPromptResultEvent } from '../../../core/model/event/string-prompt-result-event';
+import { PopupCloseEvent } from '../interface/popup-close-event';
+export declare class PromptService {
+    private _popupShower;
+    constructor(_popupShower: PopupShowerService);
+    promptString(title: string, label?: string, initialText?: string): Promise<StringPromptResultEvent>;
+    showError(textOrImageDataUri: string, title?: string, details?: string): Promise<PopupCloseEvent<void>>;
+    showWarning(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>>;
+    showNotification(textOrImageDataUri: string, title?: string, showOk?: boolean, autoClose?: boolean, hideCloseIcon?: boolean, downloadable?: boolean): Promise<boolean>;
+    showImage(imageDataUri: string, title?: string): Promise<any>;
+    showYesNo(textOrImageDataUri: string, title?: string): Promise<boolean>;
+    showModalYesNoCancel(textOrImageDataUri: string, title?: string): Promise<PopupCloseEvent<void>>;
+    showOk(text: string, title?: string): Promise<boolean>;
+    showOkCancel(text: string, title?: string): Promise<boolean>;
+    showOkModal(text: string, title?: string): Promise<boolean>;
+}

package/lib/components/popup/text-input-popup.component.d.ts

@@ -0,0 +1,12 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { PopupButtonType } from '../../core/enum/popup-button-type.enum';
+import { Popup } from './interface/popup';
+export declare class TextInputPopupComponent implements Popup<string>, AfterViewInit, OnDestroy {
+    private _changeDetector;
+    text: string;
+    label: string;
+    constructor(_changeDetector: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onClose(eventType: PopupButtonType): Promise<string>;
+}

package/lib/components/responsive-text/responsive-text.component.d.ts

@@ -0,0 +1,4 @@
+export declare class ResponsiveTextComponent {
+    text: string;
+    showClass(): boolean;
+}

package/lib/components/responsive-text/responsive-text.module.d.ts

@@ -0,0 +1,2 @@
+export declare class ResponsiveTextModule {
+}

package/lib/components/simple-grid/base-simple-grid.component.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter, QueryList } from "@angular/core";
+import { SimpleGridColumnDirective } from "./simple-grid-column.directive";
+import { CdkDrag, CdkDragDrop, CdkDropList } from "@angular/cdk/drag-drop";
+import { Subject } from "rxjs";
+export declare abstract class BaseSimpleGridComponent {
+    readonly MIN_COLUMN_WIDTH: number;
+    readonly dataChanged: Subject<void>;
+    set content(columnComponents: QueryList<SimpleGridColumnDirective>);
+    set data(value: Object[]);
+    get data(): Object[];
+    dragDropEnabled: boolean;
+    resizable: boolean;
+    inlineEdit: boolean;
+    showEdit: boolean;
+    showToolbar: boolean;
+    autoAddRow: boolean;
+    /**
+     * Should component emit drag and drop actions instead of handle
+     * (update collection) by itself
+     */
+    emitDragDrop: boolean;
+    set extraColumns(value: SimpleGridColumnDirective[]);
+    onDrop: EventEmitter<{
+        from: number;
+        to: number;
+    }>;
+    selectRow: EventEmitter<{}>;
+    dblClickRow: EventEmitter<{}>;
+    saveRow: EventEmitter<{}>;
+    deleteRow: EventEmitter<{}>;
+    addRow: EventEmitter<void>;
+    rowVisible: EventEmitter<{}>;
+    handleMouseMove(event: MouseEvent): void;
+    handleMouseUp(event: MouseEvent): void;
+    columns: SimpleGridColumnDirective[];
+    headerColumns: SimpleGridColumnDirective[];
+    protected _data: Object[];
+    protected disabledRows: number[];
+    private _columnForResize;
+    private _prepared;
+    private _startMousePositionX;
+    handleSizerMouseDown(event: MouseEvent, column: SimpleGridColumnDirective): void;
+    handleCanDragDrop(drag: CdkDrag, drop: CdkDropList): boolean;
+    handleDrop(event: CdkDragDrop<Object[]>): void;
+    isSingleColumnRow(row: Object): boolean;
+    singleColumnIndex(row: Object): number;
+    protected prepareDataRow(row: any, index: number): void;
+    private _setColumns;
+    private _prepareData;
+    private _resizeColumnsToFit;
+    private _setWidthOfAllColumns;
+}

package/lib/components/simple-grid/simple-grid-cell.component.d.ts

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { ColumnAlign, SimpleGridColumnDirective } from "./simple-grid-column.directive";
+export declare class SimpleGridCellComponent {
+    private _changeDetector;
+    get editMode(): boolean;
+    set editMode(value: boolean);
+    readonly defaultTextAlign: ColumnAlign;
+    set editTemplateContent(template: any);
+    set noEditTemplateContent(template: any);
+    set noTemplateContent(template: any);
+    column: SimpleGridColumnDirective;
+    row: {};
+    private _editMode;
+    set fieldEditMode(value: boolean);
+    get fieldEditMode(): boolean;
+    cellClick: EventEmitter<MouseEvent>;
+    showClass(): boolean;
+    handleClick(event: MouseEvent): void;
+    private _fieldEditMode;
+    private _focused;
+    private _editTemplate;
+    private _template;
+    private _inputTemplate;
+    constructor(_changeDetector: ChangeDetectorRef);
+    private _setFocusComponent;
+    private _getFirstFormInput;
+    private _createNewEvent;
+    private _getElement;
+    private _detectChanges;
+}