@provoly/dashboard 0.11.0

package/lib/dashboard/action-bus/service/control-message.interface.d.ts

@@ -0,0 +1,6 @@
+export type ControlMessageType = 'join' | 'leave';
+export interface ControlMessage {
+    type: ControlMessageType;
+    sender: string;
+    data: any;
+}

package/lib/dashboard/base-widget.module.d.ts

@@ -0,0 +1,9 @@
+import { Type } from '@angular/core';
+import { BaseWidgetComponent } from './components/widgets/base-widget.component';
+import * as i0 from "@angular/core";
+export declare class BaseWidgetModule {
+    getComponent(): Type<BaseWidgetComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseWidgetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaseWidgetModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaseWidgetModule>;
+}

package/lib/dashboard/components/context-menu/context-menu.component.d.ts

@@ -0,0 +1,59 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { SubscriptionnerDirective } from '../subscriptionner.directive';
+import { WidgetFactoryService } from '../widgets/widget-instanciator/widget-factory.service';
+import * as i0 from "@angular/core";
+export declare class ContextMenuComponent extends SubscriptionnerDirective {
+    private store;
+    private overlay;
+    private viewContainerRef;
+    widgetFactoryService: WidgetFactoryService;
+    opened$: Observable<boolean>;
+    position$: Observable<{
+        clientX: number;
+        clientY: number;
+    }>;
+    itemId$: Observable<string>;
+    itemId?: string;
+    isSelected$: Observable<boolean>;
+    resultSet: string | undefined;
+    selectedIds$: Observable<string[]>;
+    selectedItemsIds?: string[];
+    from?: string;
+    coordinates?: number[];
+    private overlayRef?;
+    template: TemplateRef<any>;
+    private overlayDetailRef?;
+    detailTemplate: TemplateRef<any>;
+    detailManifest: {
+        type: string;
+        header: boolean;
+        layout: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        options: {
+            itemIds: string[];
+        };
+    };
+    isModuleLoaded: {
+        [type: string]: boolean;
+    };
+    constructor(store: Store, overlay: Overlay, viewContainerRef: ViewContainerRef, widgetFactoryService: WidgetFactoryService);
+    openWithTemplate(position: any): void;
+    hide(): void;
+    selectionAddOrRemove(): void;
+    explore(): void;
+    proximity(): void;
+    detail(): void;
+    selectionInvert(): void;
+    addressFromLoc(): void;
+    flyingDetail(): void;
+    hideDetail(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "pry-context-menu", never, {}, {}, never, never, false, never>;
+}

package/lib/dashboard/components/context-menu/object-edition/object-edition.component.d.ts

@@ -0,0 +1,78 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { EventEmitter, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { AttributeSimpleValue, Item } from '../../../../core/model/item.interface';
+import { Attribute, Class } from '../../../../core/store/class/class.interface';
+import { Field, FieldType } from '../../../../core/store/field/field.interface';
+import { SubscriptionnerDirective } from '../../subscriptionner.directive';
+import * as i0 from "@angular/core";
+export declare const HTTP_ORIGIN_METADATA = "_http_origin";
+export declare class PryObjectEditionComponent extends SubscriptionnerDirective {
+    private overlay;
+    private viewContainerRef;
+    private store;
+    link: boolean;
+    object: boolean;
+    menu: boolean;
+    private overlayRef?;
+    template: TemplateRef<any>;
+    itemId$: Observable<string>;
+    from$: Observable<string>;
+    itemId?: string;
+    coordinates: number[] | undefined;
+    tmpObject: Item;
+    from: string;
+    closed: EventEmitter<void>;
+    classes: Class[];
+    fields: Field[];
+    FieldType: typeof FieldType;
+    relations$: Observable<{
+        id: string;
+        label: string;
+    }[]>;
+    relation: {
+        typeId: string;
+        itemId: string;
+    };
+    selectedItemsIds: string[];
+    UPLOAD_METHOD: string;
+    HTTP_ORIGIN_METHOD: string;
+    HTTP_ORIGIN_METADATA: string;
+    rawMethods: {
+        id: string;
+        name: string;
+    }[];
+    method: string;
+    selectedDatePicker: string;
+    inversion: boolean;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, store: Store);
+    openCreateObjectPanel($event: MouseEvent): void;
+    hide(): void;
+    newObject(): {
+        id: string;
+        oClass: string;
+        attributes: {};
+        metadata: {};
+    };
+    get valid(): string | boolean;
+    createObjects(): void;
+    get attributes(): Attribute[];
+    fieldType(attribute: Attribute): FieldType | undefined;
+    assignValue(attribute: Attribute, $event: any): void;
+    value(attribute: Attribute): import("../../../../core/model/item.interface").ValueType | undefined;
+    toggleDatePicker($event: Event, id: string): void;
+    closeDatePicker($event: Event): void;
+    multiValues(attribute: Attribute): AttributeSimpleValue[];
+    removeMultiValued(attribute: Attribute, i: number): void;
+    addMultiValued(attribute: Attribute): number;
+    valueMulti(attribute: Attribute, i: number): import("../../../../core/model/item.interface").ValueType;
+    assignValueMulti(attribute: Attribute, $event: any, i: number): void;
+    changeClass($event: any): void;
+    setRawMethod(attribute: Attribute, $event: any): void;
+    valueMetadata(attribute: Attribute, type: string): import("../../../../core/model/item.interface").MetadataType;
+    assignMetadata(attribute: Attribute, $event: any, type: string): void;
+    toggleInversion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PryObjectEditionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PryObjectEditionComponent, "pry-object-creation", never, { "link": { "alias": "link"; "required": false; }; "object": { "alias": "object"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, { "closed": "closed"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,99 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { AfterViewInit, ElementRef, EventEmitter, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { DashboardGridLayout, DashboardManifest, WidgetLayout, WidgetManifest } from '../../core/model/manifest.interface';
+import { DashboardCellParams } from '../store/dashboard.actions';
+import { SubscriptionnerDirective } from './subscriptionner.directive';
+import { BaseWidgetComponent } from './widgets/base-widget.component';
+import * as i0 from "@angular/core";
+export declare const MIME_TYPE_WIDGET_MANIFEST = "application/widget-manifest";
+export declare const MIME_TYPE_WIDGET_TYPE = "application/widget-type-";
+export declare const MIME_TYPE_WIDGET_SIZE = "application/widget-size-";
+export declare class DashboardComponent extends SubscriptionnerDirective implements AfterViewInit {
+    private store;
+    private overlay;
+    private viewContainerRef;
+    manifest: DashboardManifest | null;
+    windowManifest$: Observable<DashboardManifest>;
+    modeEdition: boolean;
+    modeEdition$: Observable<boolean>;
+    actionType: string | undefined;
+    staticDashboard$: BehaviorSubject<DashboardManifest | null>;
+    stacked$: BehaviorSubject<boolean>;
+    indexForRemoval: number;
+    templateModal: TemplateRef<any>;
+    separators$: Observable<WidgetLayout[]>;
+    nonFillerWidgets$: Observable<number>;
+    widgetsInstances: Array<BaseWidgetComponent>;
+    set staticDashboard(window: DashboardManifest);
+    CloseOnDragOut: boolean;
+    gridRef: ElementRef;
+    private canCalculateView;
+    targetIndexes$: Observable<number[]>;
+    dashboardParams: DashboardCellParams;
+    private breakpoint;
+    rowHeight: EventEmitter<number>;
+    rows: EventEmitter<number>;
+    currentlyModifiedManifest: WidgetManifest | null;
+    initialWidgetManifestList: WidgetManifest[];
+    move: {
+        initialX: number;
+        initialY: number;
+        previousX: number;
+        previousY: number;
+    };
+    gridTemplateRows$: Observable<string>;
+    gridTemplateColumns$: Observable<string>;
+    DashboardGridLayout: typeof DashboardGridLayout;
+    layout: DashboardGridLayout;
+    backgroundArea$: Observable<string>;
+    private confirmRemoveRef?;
+    Array: any;
+    constructor(store: Store<any>, overlay: Overlay, viewContainerRef: ViewContainerRef);
+    ngAfterViewInit(): void;
+    /***
+     * Manage display
+     */
+    calculateView(): void;
+    get displayIsStacked(): boolean;
+    gridColumn(layout: WidgetLayout): string;
+    gridRow(layout: WidgetLayout): string;
+    generateRows(rows: number): string;
+    generateColumns(columns: number): string;
+    /***
+     * Direct actions on widgets
+     */
+    remove(i: number): void;
+    moveInNewWindow(widgetIndex: number, targetIndex: number): void;
+    maximize(widgetIndex: number): void;
+    /***
+     * Manage drag n drop, move, resize
+     */
+    prepareModification($event: MouseEvent, indexManifest: number): void;
+    startResize($event: MouseEvent, indexManifest: number, direction: string): void;
+    dragStart($event: DragEvent, indexManifest: number): void;
+    private static addTransferManifestMetadata;
+    dragEnter($event: DragEvent, force?: boolean): void;
+    checkForDragEnter($event: MouseEvent): void;
+    getTarget($event: MouseEvent, optimize?: boolean): {
+        x: number;
+        y: number;
+    } | null;
+    movingMouse($event: MouseEvent, optimize?: boolean): void;
+    dragMove($event: DragEvent): void;
+    dragLeave($event: DragEvent): void;
+    dropping($event: DragEvent): void;
+    clearActions(): void;
+    /***
+     * Manage other kinds of drops (inside widgets)
+     */
+    droppingInWidget($event: DragEvent, index: number): void;
+    toggleRemoveConfirm($event?: MouseEvent, index?: number): void;
+    confirmRemove(): void;
+    cancelRemoveConfirm(): void;
+    trackWidgets(index: number, widgetManifest: WidgetManifest): string;
+    updateInstance(widgetIndex: number, $event: BaseWidgetComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "pry-dashboard", never, { "staticDashboard": { "alias": "staticDashboard"; "required": false; }; "CloseOnDragOut": { "alias": "CloseOnDragOut"; "required": false; }; }, { "rowHeight": "rowHeight"; "rows": "rows"; }, never, never, false, never>;
+}

package/lib/dashboard/components/manifests/manifests.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { ManifestDescription } from '../../../core/model/manifest.interface';
+import * as i0 from "@angular/core";
+export declare class ManifestsComponent {
+    protected store: Store<any>;
+    manifests$: Observable<ManifestDescription[]>;
+    fileInput: ElementRef<HTMLInputElement>;
+    checked: boolean[];
+    constructor(store: Store<any>);
+    fetch(id: string): void;
+    delete(id: string): void;
+    download(id: string, name: string): void;
+    handleFileInput(event: Event | null): void;
+    triggerFileInput(): void;
+    default(id: string, name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManifestsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManifestsComponent, "pry-manifests", never, {}, {}, never, never, false, never>;
+}

package/lib/dashboard/components/metadata/metadata.component.d.ts

@@ -0,0 +1,16 @@
+import { AttributeSimpleValue, Item } from '../../../core/model/item.interface';
+import * as i0 from "@angular/core";
+export declare class MetadataComponent {
+    metadata: {
+        name: string;
+        value: string | number;
+    }[];
+    id: number;
+    opened: boolean;
+    static idGenerator: number;
+    set item(item: Item | AttributeSimpleValue);
+    constructor();
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataComponent, "pry-metadata", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/dashboard/components/solve-collisions.function.d.ts

@@ -0,0 +1,15 @@
+import { DashboardManifest, WidgetManifest } from '../../core/model/manifest.interface';
+export declare function orderWidgetsAccordingToPlacement(a: WidgetManifest & {
+    layout: {
+        weight?: number;
+    };
+}, b: WidgetManifest & {
+    layout: {
+        weight?: number;
+    };
+}): number;
+export declare const solvingCollisionOptions: {
+    invertedGravity: boolean;
+    minRows: number;
+};
+export declare function solveCollisions(candidateWidget: WidgetManifest, initialWidgetManifestList: WidgetManifest[], dashboardManifest: DashboardManifest): DashboardManifest;

package/lib/dashboard/components/subscriptionner.directive.d.ts

@@ -0,0 +1,9 @@
+import { OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SubscriptionnerDirective implements OnDestroy {
+    subscriptions: Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionnerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SubscriptionnerDirective, never, never, {}, {}, never, never, false, never>;
+}

package/lib/dashboard/components/vizualize-raw/vizualize-raw.component.d.ts

@@ -0,0 +1,26 @@
+import { SafeUrl } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { Item } from '../../../core/model/item.interface';
+import { RawService } from '../../../core/store/raw/raw.service';
+import * as i0 from "@angular/core";
+export declare class VizualizeRawComponent {
+    private rawService;
+    item?: Item;
+    propertyName: string;
+    alt?: string;
+    private _altDefault;
+    get altValue(): string;
+    constructor(rawService: RawService);
+    rawDatas: {
+        [key: string]: {
+            type: string;
+            url: SafeUrl;
+        };
+    };
+    getRawData(itemId: string, attributeName: string): Observable<{
+        type: string;
+        url: SafeUrl;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VizualizeRawComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VizualizeRawComponent, "pry-vizualize-raw", never, { "item": { "alias": "item"; "required": false; }; "propertyName": { "alias": "propertyName"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/dashboard/components/widgets/base-widget.component.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewChecked, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { WidgetManifest } from '../../../core/model/manifest.interface';
+import { Size } from '../../../core/model/widget-chart-manifest.interface';
+import { SubscriptionnerDirective } from '../subscriptionner.directive';
+import * as i0 from "@angular/core";
+export declare class BaseWidgetComponent extends SubscriptionnerDirective implements OnDestroy, AfterViewChecked {
+    protected store: Store<any>;
+    protected el: ElementRef;
+    widgetIndex$: BehaviorSubject<number>;
+    manifest$: Observable<WidgetManifest>;
+    manifest: WidgetManifest;
+    sub?: Subscription;
+    observableList$: BehaviorSubject<Observable<WidgetManifest>[]>;
+    staticManifest$: BehaviorSubject<WidgetManifest | null>;
+    displayHeader$: Observable<boolean | {
+        [key: string]: boolean;
+    }>;
+    private _widgetSize$;
+    widgetSize$: Observable<Size>;
+    open$: Observable<void> | Subject<void>;
+    manifestModified: EventEmitter<{
+        widgetIndex: number;
+        manifest: WidgetManifest;
+    }>;
+    set widgetIndex(index: number);
+    set staticManifest(manifest: WidgetManifest);
+    set _manifest$(manifest: Observable<WidgetManifest>);
+    get widgetIndex(): number;
+    constructor(store: Store<any>, el: ElementRef);
+    ngAfterViewChecked(): void;
+    toImage(): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseWidgetComponent, "pry-base-widget", never, { "open$": { "alias": "open$"; "required": false; }; "widgetIndex": { "alias": "widgetIndex"; "required": false; }; "staticManifest": { "alias": "staticManifest"; "required": false; }; }, { "manifestModified": "manifestModified"; }, never, never, false, never>;
+}

package/lib/dashboard/components/widgets/data-widget.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Item } from '../../../core/model/item.interface';
+import { ResultSet } from '../../../core/model/result-set.interface';
+import { DataSource } from '../../../core/store/data-source/data-source.model';
+import { BaseWidgetComponent } from './base-widget.component';
+import * as i0 from "@angular/core";
+export declare class DataWidgetComponent extends BaseWidgetComponent {
+    resultSet$: Observable<ResultSet>;
+    staticResultSet$: BehaviorSubject<ResultSet | null>;
+    datasourceIds$: Observable<string[]>;
+    allItems$: Observable<Item[]>;
+    usedDatasources$: Observable<DataSource[]>;
+    set staticResultSet(resultSet: ResultSet);
+    constructor(store: Store<any>, el: ElementRef);
+    initResultSet$(): Observable<ResultSet>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataWidgetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataWidgetComponent, "pry-data-widget", never, { "staticResultSet": { "alias": "staticResultSet"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/dashboard/components/widgets/header/resultset-size.pipe.d.ts

@@ -0,0 +1,18 @@
+import { PipeTransform } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { PryI18nService } from '../../../../core/i18n/i18n.service';
+import * as i0 from "@angular/core";
+export declare class ResultSetSizePipe implements PipeTransform {
+    private store;
+    private translate;
+    constructor(store: Store, translate: PryI18nService);
+    transform(_name: string | string[]): Observable<string>;
+    calculate(name: string): Observable<{
+        displayed: number;
+        total: number;
+        accurate: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultSetSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResultSetSizePipe, "resultSetSize", false>;
+}

package/lib/dashboard/components/widgets/header/widget-header.component.d.ts

@@ -0,0 +1,115 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ElementRef, EventEmitter, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { DashboardGridLayout, DashboardManifest, WidgetManifest } from '../../../../core/model/manifest.interface';
+import { Widget } from '../../../../core/model/widget.interface';
+import { DataSource } from '../../../../core/store/data-source/data-source.model';
+import { LibraryTypes } from '../../../../core/store/image/image.service';
+import { ToolboxMenuService } from '../../../../core/toolbox/toolbox-menu.service';
+import { SubscriptionnerDirective } from '../../subscriptionner.directive';
+import * as i0 from "@angular/core";
+export declare const WIDGET_HEADER_HEIGHT = 60;
+export type HeaderAction = {
+    icon: string;
+    action: (that: PryWidgetHeaderComponent) => void;
+    label: string;
+    disabled?: (that: PryWidgetHeaderComponent) => boolean;
+};
+export declare class PryWidgetHeaderComponent extends SubscriptionnerDirective {
+    private store;
+    private overlay;
+    private viewContainerRef;
+    toolboxMenuService: ToolboxMenuService;
+    template: TemplateRef<any>;
+    templateModal: TemplateRef<any>;
+    toggle: TemplateRef<any>;
+    overlayMenu: TemplateRef<any>;
+    overlayCatalog: TemplateRef<any>;
+    overlaySpot: TemplateRef<any>;
+    togglePanel: ElementRef<HTMLButtonElement>;
+    cross: ElementRef<HTMLButtonElement>;
+    validate: ElementRef<HTMLButtonElement>;
+    validateCatalog: ElementRef<HTMLButtonElement>;
+    cancel: ElementRef<HTMLButtonElement>;
+    crossCatalog: ElementRef<HTMLButtonElement>;
+    inputCatalog: ElementRef<HTMLInputElement>;
+    menuList: ElementRef;
+    manifest$: BehaviorSubject<WidgetManifest | null>;
+    subscription?: Subscription;
+    places: WidgetManifest[];
+    selectedItem?: Element | null;
+    set manifest(manifest: WidgetManifest | null);
+    additionalOptions: HeaderAction[] | null;
+    headerOptions: {
+        [key: string]: boolean;
+    } | {} | undefined;
+    displayCount: boolean;
+    manifestModified: EventEmitter<{
+        widgetIndex: number;
+        manifest: WidgetManifest;
+    }>;
+    isEdit: boolean;
+    catalogInfo: Widget;
+    get title(): string | undefined;
+    get manifest(): WidgetManifest | null;
+    set datasourceIds$(datasourceIds$: Observable<string[]>);
+    set widgetIndex(widgetIndex: number);
+    search$: BehaviorSubject<string>;
+    lockedView$: Observable<boolean>;
+    targetIndexes$: Observable<number[]>;
+    usedDatasources$: Observable<DataSource[]>;
+    allDataSources$: Observable<DataSource[]>;
+    usedNameQueryIds: string[];
+    choiceUsed: {
+        [is: string]: boolean;
+    };
+    _widgetIndex$: BehaviorSubject<number>;
+    _widgetIndex: number;
+    open: boolean;
+    selectedDataSource: string[];
+    idToNameDatasource: {
+        [id: string]: string;
+    };
+    windowManifest: DashboardManifest | null;
+    private windowManifest$;
+    private menuRef?;
+    private comboRef?;
+    private confirmRemoveRef?;
+    private catalogRef?;
+    private spotRef?;
+    menu: boolean;
+    type: LibraryTypes;
+    constructor(store: Store, overlay: Overlay, viewContainerRef: ViewContainerRef, toolboxMenuService: ToolboxMenuService);
+    onArrowUp(): void;
+    onArrowDown(): void;
+    get currentLayout(): DashboardGridLayout;
+    get hasGrid(): boolean;
+    get currentPlacementIndex(): number;
+    toogleDataSource(id: string): void;
+    menuOpen($event?: MouseEvent, forceOpen?: boolean): void;
+    toggleCombo(): void;
+    moveInNewWindow(widgetIndex: number, targetIndex: number): void;
+    maximize(widgetIndex: number): void;
+    emitManifest(): void;
+    toggleRemoveConfirm($event?: MouseEvent): void;
+    confirmRemove(): void;
+    remove(): void;
+    cancelRemoveConfirm(): void;
+    toggleCatalog(): void;
+    confirmCatalog(): void;
+    executeAction(options: HeaderAction): void;
+    isActionDisabled(option: HeaderAction): boolean;
+    displayOption(headerOptions: any, parameters: string): boolean;
+    displaySettings(headerOptions: {
+        [p: string]: boolean;
+    } | {} | undefined): boolean;
+    toggleChangeSpot(): void;
+    moveToPlace(place: WidgetManifest): void;
+    focusCrossElement(): void;
+    focusValidation(): void;
+    focusInputCatalog(): void;
+    disableValidation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PryWidgetHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PryWidgetHeaderComponent, "pry-widget-header", never, { "manifest": { "alias": "manifest"; "required": false; }; "additionalOptions": { "alias": "additionalOptions"; "required": false; }; "headerOptions": { "alias": "headerOptions"; "required": false; }; "displayCount": { "alias": "displayCount"; "required": false; }; "datasourceIds$": { "alias": "datasourceIds$"; "required": false; }; "widgetIndex": { "alias": "widgetIndex"; "required": false; }; }, { "manifestModified": "manifestModified"; }, never, ["*"], false, never>;
+}

package/lib/dashboard/components/widgets/public-api.d.ts

@@ -0,0 +1,9 @@
+export * from './base-widget.component';
+export * from './data-widget.component';
+export * from './header/widget-header.component';
+export * from './header/resultset-size.pipe';
+export * from './widget-instanciator/widget-factory.service';
+export * from './widget-instanciator/widget-instanciator.component';
+export * from './widget-instanciator/widgets-definition.model';
+export * from './widget-placeholder/widget-placeholder.component';
+export * from './settings/settings.component';

package/lib/dashboard/components/widgets/settings/settings.component.d.ts

@@ -0,0 +1,35 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ElementRef, EventEmitter, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { PryWidgetHeaderComponent } from '../header/widget-header.component';
+import * as i0 from "@angular/core";
+export declare class SettingsComponent implements OnDestroy {
+    private store;
+    private overlay;
+    private viewContainerRef;
+    _widgetIndex$: BehaviorSubject<number>;
+    private openSub?;
+    set widgetIndex(widgetIndex: number);
+    isDisable?: boolean;
+    headerPresent: boolean | null | {
+        [key: string]: boolean;
+    };
+    set open$(open$: Observable<void> | Subject<void>);
+    header?: PryWidgetHeaderComponent;
+    saveTriggered: EventEmitter<void>;
+    open: boolean;
+    private overlayRef?;
+    template: TemplateRef<any>;
+    cross: ElementRef<HTMLButtonElement>;
+    validate: ElementRef<HTMLButtonElement>;
+    constructor(store: Store<any>, overlay: Overlay, viewContainerRef: ViewContainerRef);
+    toggle(): void;
+    saveAndClose(): void;
+    openWithTemplate(): void;
+    focusCrossElement(): void;
+    focusValidation(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "pry-settings", never, { "widgetIndex": { "alias": "widgetIndex"; "required": false; }; "isDisable": { "alias": "isDisable"; "required": false; }; "headerPresent": { "alias": "headerPresent"; "required": false; }; "open$": { "alias": "open$"; "required": false; }; "header": { "alias": "header"; "required": false; }; }, { "saveTriggered": "saveTriggered"; }, never, ["*"], false, never>;
+}

package/lib/dashboard/components/widgets/widget-filler/widget-filler.component.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { BaseWidgetComponent } from '../base-widget.component';
+import * as i0 from "@angular/core";
+export declare class WidgetFillerComponent extends BaseWidgetComponent {
+    constructor(store: Store<any>, el: ElementRef);
+    get index(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetFillerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetFillerComponent, "pry-widget-filler", never, {}, {}, never, never, false, never>;
+}

package/lib/dashboard/components/widgets/widget-instanciator/widget-factory.service.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken, Injector, Type } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { WidgetManifest } from '../../../../core/model/manifest.interface';
+import { BaseWidgetComponent } from '../base-widget.component';
+import { WidgetDefinition } from './widgets-definition.model';
+import * as i0 from "@angular/core";
+export declare const WIDGET_DEFINITION: InjectionToken<string>;
+export declare class WidgetFactoryService {
+    private injector;
+    reference$: BehaviorSubject<{
+        [key: string]: WidgetDefinition;
+    }>;
+    moduleRefCache: {
+        [manifestType: string]: Type<BaseWidgetComponent>;
+    };
+    constructor(injector: Injector, reference: {
+        [key: string]: WidgetDefinition;
+    });
+    resolveComponent(manifest: WidgetManifest): Observable<Type<BaseWidgetComponent>>;
+    private putDefinitions;
+    isModuleLoaded(type: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetFactoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetFactoryService>;
+}