wuic-framework-lib 0.0.1

package/lib/component/workflow-designer/workflow-designer.component.d.ts

@@ -0,0 +1,262 @@
+import { AfterViewInit, ElementRef, EventEmitter, Injector, OnDestroy } from '@angular/core';
+import { MenuItem } from 'primeng/api';
+import { AutoCompleteCompleteEvent } from 'primeng/autocomplete';
+import { ContextMenu } from 'primeng/contextmenu';
+import { DataProviderService } from '../../service/data-provider.service';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { MetadataEditorComponent } from '../metadata-editor/metadata-editor.component';
+import * as i0 from "@angular/core";
+type PaletteNodeDefinition = {
+    type: 'start' | 'route' | 'action' | 'condition' | 'end';
+    label: string;
+    description: string;
+};
+type WorkflowMenuAuthorization = {
+    mmid: number;
+    muamid: number;
+    muamview: 0 | 1;
+    ruoloid: number;
+    utenteid: number;
+};
+type WorkflowStartMenuItem = {
+    mm_id: number;
+    mm_parent_id: number;
+    mm_nome_menu: string;
+    mm_display_string_menu: string;
+    mm_tooltip_menu: string;
+    mm_uri_menu: string;
+    mm_ordine: number;
+    mm_is_visible_by_default: boolean;
+    _Metadati_Utenti_Autorizzazioni_Menus: WorkflowMenuAuthorization[];
+};
+export declare class WorkflowDesignerComponent implements AfterViewInit, OnDestroy {
+    private injector;
+    private dataSrv;
+    workflowCanvasRef?: ElementRef<HTMLDivElement>;
+    primeContextMenu?: ContextMenu;
+    routeMetadataDs?: DataSourceComponent;
+    startMenuDs?: DataSourceComponent;
+    menuAuthDs?: DataSourceComponent;
+    routeMetadataEditor?: MetadataEditorComponent;
+    actionMetadataEditor?: MetadataEditorComponent;
+    workflowChange: EventEmitter<any>;
+    readonly paletteNodes: PaletteNodeDefinition[];
+    private readonly socket;
+    private editor?;
+    private area?;
+    contextMenuItems: MenuItem[];
+    contextMenuNodeId: string | null;
+    contextMenuNodeType: string;
+    routePopupVisible: boolean;
+    routeSourceOptions: Array<{
+        label: string;
+        value: 'route' | 'dashboard';
+    }>;
+    selectedRouteSourceType: 'route' | 'dashboard';
+    routeOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    dashboardOptions: Array<{
+        label: string;
+        value: string;
+        boardcontent: string;
+    }>;
+    filteredRouteOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    filteredDashboardOptions: Array<{
+        label: string;
+        value: string;
+        boardcontent: string;
+    }>;
+    routeActionOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    selectedRouteName: string;
+    selectedDashboardRoute: string;
+    selectedRouteAction: string;
+    private pendingRouteDrop;
+    actionPopupVisible: boolean;
+    actionTypeOptions: Array<{
+        label: string;
+        value: number;
+    }>;
+    selectedActionTypeId: number | null;
+    actionScopeOptions: Array<{
+        label: string;
+        value: number;
+    }>;
+    selectedActionScopeId: number | null;
+    private pendingActionDrop;
+    private readonly actionTypeDictionaryValue;
+    routeMetadataDialogVisible: boolean;
+    routeMetadataRoute: string;
+    workflowKey: string;
+    workflowName: string;
+    savingWorkflow: boolean;
+    loadingWorkflow: boolean;
+    savedGraphOptions: Array<{
+        label: string;
+        value: string;
+        name: string;
+    }>;
+    selectedSavedGraphKey: string;
+    reopenWorkflowDialogVisible: boolean;
+    reopenDialogSelectedGraphKey: string;
+    workflowOptionsDialogVisible: boolean;
+    workflowOptionsStartNodeId: string;
+    workflowOptionsCaption: string;
+    workflowOptionsInheritMetadata: boolean;
+    workflowOptionsExclusiveMenu: boolean;
+    workflowOptionsShowExit: boolean;
+    loadingSavedGraphs: boolean;
+    graphActionsMenuItems: MenuItem[];
+    runnerActionsMenuItems: MenuItem[];
+    private routeMetadataNodeId;
+    private routeMetadataDashboardDatasourceUniqueName;
+    private lastCreatedRouteNodeId;
+    private pendingMenuAuthContext;
+    private pendingStartMenuContext;
+    private localMenuIdSeed;
+    private readonly startMenuRoute;
+    private readonly menuAuthRoute;
+    readonly routeMetadataSaveCallback: Function;
+    readonly startMenuSaveCallback: Function;
+    readonly menuAuthSaveCallback: Function;
+    constructor(injector: Injector, dataSrv: DataProviderService);
+    ngAfterViewInit(): Promise<void>;
+    ngOnDestroy(): void;
+    onPaletteDragStart(event: DragEvent, node: PaletteNodeDefinition): void;
+    onCanvasDragOver(event: DragEvent): void;
+    onCanvasDrop(event: DragEvent): Promise<void>;
+    onCanvasContextMenu(event: MouseEvent): void;
+    onCanvasClick(): void;
+    deleteContextNode(): Promise<void>;
+    openRouteMetadataFromContext(dashboardDatasourceUniqueName?: string | null): Promise<void>;
+    openActionMetadataFromContext(): Promise<void>;
+    get contextStartMenuItems(): WorkflowStartMenuItem[];
+    addStartMenuFromContext(): Promise<void>;
+    renameStartMenuFromContext(menuInput: WorkflowStartMenuItem | number): Promise<void>;
+    private openStartMenuEditor;
+    private handleStartMenuSave;
+    openInsertMenuAuthorizationFromContext(menuIdRaw: number): Promise<void>;
+    openEditMenuAuthorizationFromContext(menuIdRaw: number, muamIdRaw: number): Promise<void>;
+    deleteMenuAuthorizationFromContext(menuIdRaw: number, muamIdRaw: number): void;
+    getMenuAuthorizationsForContext(menuIdRaw: number): WorkflowMenuAuthorization[];
+    getMenuAuthorizationLabel(auth: WorkflowMenuAuthorization): string;
+    deleteStartMenuFromContext(menuIdRaw: number): Promise<void>;
+    editStartMenuCaptionFromContext(): void;
+    openWorkflowOptionsFromContext(): void;
+    cancelWorkflowOptionsDialog(): void;
+    confirmWorkflowOptionsDialog(): void;
+    private openMenuAuthorizationEditor;
+    private configureMenuAuthorizationEditorMeta;
+    private handleMenuAuthorizationSave;
+    confirmRouteDrop(): Promise<void>;
+    cancelRouteDrop(): void;
+    confirmActionDrop(): Promise<void>;
+    cancelActionDrop(): void;
+    private createNode;
+    private addNodeByType;
+    private autoConnectRouteToAction;
+    private autoConnectStartToRoute;
+    private resolveRouteNodeForAutoConnect;
+    private emitWorkflow;
+    private applyNodeVisualState;
+    private normalizeActionNodeVisualContext;
+    private inferActionTypeIdFromDescription;
+    private computeNodeLabel;
+    private getActionTypeVisualLabel;
+    private resolveNodeVisual;
+    private findNodeHostElement;
+    private hideContextMenu;
+    private buildContextMenuItems;
+    private getNodeIdFromEvent;
+    private getNodeIdFromDragEvent;
+    private openRoutePopup;
+    onRouteSourceTypeChanged(): void;
+    private openActionPopup;
+    private loadRouteOptions;
+    private loadDashboardOptions;
+    filterRouteOptions(event: AutoCompleteCompleteEvent): void;
+    filterDashboardOptions(event: AutoCompleteCompleteEvent): void;
+    private getActionTypeById;
+    private getActionScopeById;
+    private parseActionTypeOptions;
+    private getNodeById;
+    private toBoolean;
+    private getRouteSourceType;
+    private resolveRouteNodeForAction;
+    private ensureRouteMetadataBundleForNode;
+    private attachActionMetadataToRouteBundle;
+    private nextLocalNumericId;
+    private maxNumericField;
+    private toMetadataSafeName;
+    private waitForRouteMetadataEditor;
+    private waitForActionMetadataEditor;
+    saveWorkflow(): Promise<void>;
+    private generateWorkflowKey;
+    loadWorkflow(): Promise<void>;
+    refreshSavedGraphs(preselectKey?: string): Promise<void>;
+    onSavedGraphSelectionChange(): void;
+    openReopenWorkflowDialog(): Promise<void>;
+    confirmReopenWorkflowDialog(): Promise<void>;
+    cancelReopenWorkflowDialog(): void;
+    openSelectedGraph(): Promise<void>;
+    renameSelectedGraph(): Promise<void>;
+    deleteSelectedGraph(): Promise<void>;
+    createNewWorkflow(): Promise<void>;
+    get currentSavedGraphKey(): string;
+    get canOpenWorkflowRunner(): boolean;
+    get currentGraphCaption(): string;
+    private refreshToolbarMenuItems;
+    openWorkflowRunnerInNewTab(): void;
+    private serializeGraphPayload;
+    private syncRouteMetadataActionTypesFromLinkedNodes;
+    private extractRouteMetadataEntries;
+    private restoreGraph;
+    private findStartNode;
+    private ensureInitialStartNode;
+    private refreshAllNodeVisualState;
+    private rehydrateNodeVisualStateAfterRestore;
+    private clearGraph;
+    private normalizeLoadedWorkflow;
+    private normalizeSavedGraphs;
+    private parseMaybeJson;
+    private pickFirstDefined;
+    private sanitizeForSerialization;
+    private nextLocalMenuId;
+    private normalizeStartMenuItems;
+    private normalizeMenuAuthorizations;
+    private nextLocalMenuAuthId;
+    private buildRouteMetadataBundle;
+    private buildRouteMetadataBundleFromMetaInfo;
+    private extractDashboardDatasourceMetadata;
+    private getDashboardDatasourceMetadataEntries;
+    private getDashboardDatasourceMetadataForNode;
+    private handleRouteMetadataSave;
+    private syncLinkedActionNodesFromMetadataSave;
+    private syncTableActionNodesWithMetadata;
+    private removeRecordFromBundle;
+    private isLinkedActionNode;
+    private applyLinkedActionTypeToNode;
+    private removeInvalidOutgoingConnections;
+    private normalizeEditFormRecord;
+    private unwrapEditorFieldValue;
+    private createEmptyRouteBundle;
+    private applyRecordToBundle;
+    private nextLocalBundleItemId;
+    private upsertById;
+    private rebuildDerivedRouteCollections;
+    private applyRouteMetadataBundleToDatasource;
+    private buildMetaInfoFromRouteMetadataBundle;
+    private updateDashboardBoardcontentMetadata;
+    private t;
+    private tf;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowDesignerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowDesignerComponent, "wuic-workflow-designer", never, {}, { "workflowChange": "workflowChange"; }, never, never, true, never>;
+}
+export {};

package/lib/component/workflow-runner/workflow-runner.component.d.ts

@@ -0,0 +1,91 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { DataProviderService } from '../../service/data-provider.service';
+import { WorkflowRuntimeMetadataService } from '../../service/workflow-runtime-metadata.service';
+import { WorkflowRuntimeMenuService } from '../../service/workflow-runtime-menu.service';
+import { UserInfoService } from '../../service/user-info.service';
+import * as i0 from "@angular/core";
+type WorkflowMenuAuthorization = {
+    mmid: number;
+    muamid: number;
+    muamview: 0 | 1;
+    ruoloid: number;
+    utenteid: number;
+};
+type WorkflowStartMenuItem = {
+    mm_id: number;
+    mm_parent_id: number;
+    mm_nome_menu: string;
+    mm_display_string_menu: string;
+    mm_tooltip_menu: string;
+    mm_uri_menu: string;
+    mm_ordine: number;
+    mm_is_visible_by_default: boolean;
+    _Metadati_Utenti_Autorizzazioni_Menus: WorkflowMenuAuthorization[];
+};
+type WorkflowNodeSerialized = {
+    id: string;
+    label: string;
+    type: string;
+    route: string;
+    action: string;
+    routeSourceType?: 'route' | 'dashboard';
+    dashboardDatasources?: Array<{
+        uniqueName: string;
+        route: string;
+        metadataBundle: any | null;
+    }>;
+    actionTypeId?: number;
+    actionType?: string;
+    routeNodeId?: string;
+    metadataTargetType?: 'table_action' | 'column_button' | '';
+    metadataTargetId?: number;
+    startMenus?: WorkflowStartMenuItem[];
+    startMenuCaption?: string;
+    startExclusiveMenu?: boolean;
+    startShowExit?: boolean;
+    routeMetadata?: any;
+};
+type WorkflowConnectionSerialized = {
+    id?: string;
+    source: string;
+    sourceOutput: string;
+    target: string;
+    targetInput: string;
+};
+export declare class WorkflowRunnerComponent implements OnInit, OnDestroy {
+    private route;
+    private dataSrv;
+    private runtimeMetadataSrv;
+    private runtimeMenuSrv;
+    private userInfo;
+    graphId: string;
+    graphName: string;
+    loading: boolean;
+    loadError: string;
+    nodes: WorkflowNodeSerialized[];
+    connections: WorkflowConnectionSerialized[];
+    routeMetadataByNodeId: Map<string, any>;
+    private paramSub?;
+    constructor(route: ActivatedRoute, dataSrv: DataProviderService, runtimeMetadataSrv: WorkflowRuntimeMetadataService, runtimeMenuSrv: WorkflowRuntimeMenuService, userInfo: UserInfoService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get startNode(): WorkflowNodeSerialized | null;
+    get routeNodesConnectedToStart(): WorkflowNodeSerialized[];
+    get routeMetadataCount(): number;
+    private loadGraph;
+    private applyRuntimeMenus;
+    private isStartMenuVisible;
+    private normalizeStartMenus;
+    private normalizeMenuAuthorizations;
+    private buildStartMenuTree;
+    private normalizeRoutePath;
+    private buildLinkedActionRouteMetadataEntries;
+    private normalizeLoadedWorkflow;
+    private parseMaybeJson;
+    private pickFirstDefined;
+    private toBoolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowRunnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WorkflowRunnerComponent, "wuic-workflow-runner", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/directive/angular-resizable.directive.d.ts

@@ -0,0 +1,153 @@
+import { ElementRef, EventEmitter, Renderer2, SimpleChanges } from '@angular/core';
+import { ResizeHandle } from './helpers/resize-handle';
+import { ResizeHandleType } from './models/resize-handle-type';
+import { IResizeEvent } from './models/resize-event';
+import * as i0 from "@angular/core";
+export declare class AngularResizableDirective {
+    private el;
+    private renderer;
+    private _resizable;
+    private _handles;
+    private _handleType;
+    private _handleResizing;
+    private _direction;
+    private _directionChanged;
+    private _aspectRatio;
+    private _containment;
+    private _origMousePos;
+    /** Original Size and Position */
+    private _origSize;
+    private _origPos;
+    /** Current Size and Position */
+    private _currSize;
+    private _currPos;
+    /** Initial Size and Position */
+    private _initSize;
+    private _initPos;
+    /** Snap to gird */
+    private _gridSize;
+    private _bounding;
+    /**
+     * Bugfix: iFrames, and context unrelated elements block all events, and are unusable
+     * https://github.com/xieziyu/angular2-draggable/issues/84
+     */
+    private _helperBlock;
+    private draggingSub;
+    private _adjusted;
+    /** Disables the resizable if set to false. */
+    set ngResizable(v: any);
+    /**
+     * Which handles can be used for resizing.
+     * @example
+     * [rzHandles] = "'n,e,s,w,se,ne,sw,nw'"
+     * equals to: [rzHandles] = "'all'"
+     *
+     * */
+    rzHandles: ResizeHandleType;
+    /**
+     * Using exist handles for resizing instead of generate them.
+     * @example
+     * [rzHandleDoms] = {
+     *   e: handelE,
+     *   s: handelS,
+     *   se: handelSE
+     * };
+     * */
+    rzHandleDoms: {
+        se?: ElementRef;
+        sw?: ElementRef;
+        ne?: ElementRef;
+        nw?: ElementRef;
+        n?: ElementRef;
+        e?: ElementRef;
+        s?: ElementRef;
+        w?: ElementRef;
+    };
+    /**
+     * Whether the element should be constrained to a specific aspect ratio.
+     *  Multiple types supported:
+     *  boolean: When set to true, the element will maintain its original aspect ratio.
+     *  number: Force the element to maintain a specific aspect ratio during resizing.
+     */
+    rzAspectRatio: boolean | number;
+    /**
+     * Constrains resizing to within the bounds of the specified element or region.
+     *  Multiple types supported:
+     *  Selector: The resizable element will be contained to the bounding box of the first element found by the selector.
+     *            If no element is found, no containment will be set.
+     *  Element: The resizable element will be contained to the bounding box of this element.
+     *  String: Possible values: "parent".
+     */
+    rzContainment: string | HTMLElement;
+    /**
+     * Snaps the resizing element to a grid, every x and y pixels.
+     * A number for both width and height or an array values like [ x, y ]
+     */
+    rzGrid: number | number[];
+    /** The minimum width the resizable should be allowed to resize to. */
+    rzMinWidth: number;
+    /** The minimum height the resizable should be allowed to resize to. */
+    rzMinHeight: number;
+    /** The maximum width the resizable should be allowed to resize to. */
+    rzMaxWidth: number;
+    /** The maximum height the resizable should be allowed to resize to. */
+    rzMaxHeight: number;
+    /** Input css scale transform of element so translations are correct */
+    rzScale: number;
+    /** Whether to prevent default event */
+    preventDefaultEvent: boolean;
+    /** emitted when start resizing */
+    rzStart: EventEmitter<IResizeEvent>;
+    /** emitted when start resizing */
+    rzResizing: EventEmitter<IResizeEvent>;
+    /** emitted when stop resizing */
+    rzStop: EventEmitter<IResizeEvent>;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    /** A method to reset size */
+    resetSize(): void;
+    /** A method to get current status */
+    getStatus(): {
+        size: {
+            width: number;
+            height: number;
+        };
+        position: {
+            top: number;
+            left: number;
+        };
+    };
+    private updateResizable;
+    /** Use it to update aspect */
+    private updateAspectRatio;
+    /** Use it to update containment */
+    private updateContainment;
+    /** Use it to create handle divs */
+    private createHandles;
+    /** Use it to create a handle */
+    private createHandleByType;
+    private removeHandles;
+    onMouseDown(event: MouseEvent | TouchEvent, handle: ResizeHandle): void;
+    private subscribeEvents;
+    private unsubscribeEvents;
+    onMouseLeave(): void;
+    onMouseMove(event: MouseEvent | TouchEvent): void;
+    private startResize;
+    private stopResize;
+    private onResizing;
+    private getResizingEvent;
+    private updateDirection;
+    private resizeTo;
+    private doResize;
+    private adjustByRatio;
+    private checkBounds;
+    private checkSize;
+    private getBounding;
+    private resetBounding;
+    private getGridSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularResizableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AngularResizableDirective, "[ngResizable]", never, { "ngResizable": { "alias": "ngResizable"; "required": false; }; "rzHandles": { "alias": "rzHandles"; "required": false; }; "rzHandleDoms": { "alias": "rzHandleDoms"; "required": false; }; "rzAspectRatio": { "alias": "rzAspectRatio"; "required": false; }; "rzContainment": { "alias": "rzContainment"; "required": false; }; "rzGrid": { "alias": "rzGrid"; "required": false; }; "rzMinWidth": { "alias": "rzMinWidth"; "required": false; }; "rzMinHeight": { "alias": "rzMinHeight"; "required": false; }; "rzMaxWidth": { "alias": "rzMaxWidth"; "required": false; }; "rzMaxHeight": { "alias": "rzMaxHeight"; "required": false; }; "rzScale": { "alias": "rzScale"; "required": false; }; "preventDefaultEvent": { "alias": "preventDefaultEvent"; "required": false; }; }, { "rzStart": "rzStart"; "rzResizing": "rzResizing"; "rzStop": "rzStop"; }, never, never, true, never>;
+}

package/lib/directive/classes/ngx-draggable-point.d.ts

@@ -0,0 +1,5 @@
+export declare class NgxDraggablePoint {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+}

package/lib/directive/classes/ngx-draggable-rect.d.ts

@@ -0,0 +1,27 @@
+export declare class NgxDraggableRect implements DOMRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * The left edge of the rectangle.
+     */
+    get left(): number;
+    /**
+     * The top edge of the rectangle.
+     */
+    get top(): number;
+    /**
+     * The right edge of the rectangle.
+     */
+    get right(): number;
+    /**
+     * The bottom edge of the rectangle.
+     */
+    get bottom(): number;
+    /**
+     * Receive the draggable rect in json format.
+     */
+    get toJSON(): any;
+    constructor(x: number, y: number, width: number, height: number);
+}

package/lib/directive/data-bound.directive.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetectorRef, ElementRef, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DataBoundDirective implements OnChanges {
+    private element;
+    private cd;
+    databound: any;
+    bindingFunction: string;
+    clickCallback: any;
+    itemTemplate: string;
+    inputs: any;
+    private ds;
+    constructor(element: ElementRef, cd: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataBoundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataBoundDirective, "[databound]", never, { "databound": { "alias": "databound"; "required": false; }; "bindingFunction": { "alias": "bindingFunction"; "required": false; }; "clickCallback": { "alias": "clickCallback"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directive/events/ngx-draggable-dom-bounds-check-event.d.ts

@@ -0,0 +1,32 @@
+import { NgxDraggablePoint } from '../classes/ngx-draggable-point';
+/**
+ * This object class represents a boundary check event that can be emitted by the directive indicating to the consumer
+ * which edges are intersecting with the boundary defined to constrain the draggable element.
+ */
+export declare class NgxDraggableDomBoundsCheckEvent {
+    readonly top: boolean;
+    readonly right: boolean;
+    readonly bottom: boolean;
+    readonly left: boolean;
+    readonly constrainedCenter: NgxDraggablePoint | undefined;
+    readonly translation: NgxDraggablePoint;
+    readonly isConstrained: boolean;
+    /**
+     * Read only property that indicates if one or more of the boundaries have been collided with.
+     *
+     * @return True if any of the boundaries are collided.
+     */
+    get hasCollision(): boolean;
+    /**
+     * Constructs the bounds check event with default properties.
+     *
+     * @param top Whether the top edge has been breached or not.
+     * @param right Whether the right edge has been breached or not.
+     * @param bottom Whether the bottom edge has been breached or not.
+     * @param left Whether the left edge has been breached or not.
+     * @param elP0 The center point of the element if it were to be constrained by these bounds.
+     * @param translation The calculated translation from the starting point based on any bounds constraints.
+     * @param isConstrained Whether the element should be constrained or not.
+     */
+    constructor(top: boolean, right: boolean, bottom: boolean, left: boolean, elP0: NgxDraggablePoint, translation: NgxDraggablePoint, isConstrained: boolean);
+}

package/lib/directive/events/ngx-draggable-dom-move-event.d.ts

@@ -0,0 +1,28 @@
+import { NgxDraggablePoint } from '../classes/ngx-draggable-point';
+/**
+ * This object class represents a move event that can be emitted by the directive indicating to the consumer
+ * the position of the target element.
+ */
+export declare class NgxDraggableDomMoveEvent {
+    private _target;
+    private _position;
+    /**
+     * Read only property that indicates what element is being moved.
+     *
+     * @return The reference to the HTMLElement being moved.
+     */
+    get target(): HTMLElement | undefined;
+    /**
+     * Read only property that indicates the position of the element.
+     *
+     * @return The position of the target element as a NgxDraggablePoint.
+     */
+    get position(): NgxDraggablePoint | undefined;
+    /**
+     * Constructs the move event with specified property values.
+     *
+     * @param target The target HTMLElement that was moved.
+     * @param position The position of the target HTMLElement.
+     */
+    constructor(target: HTMLElement, position: NgxDraggablePoint);
+}

package/lib/directive/helpers/helper-block.d.ts

@@ -0,0 +1,12 @@
+import { Renderer2 } from '@angular/core';
+export declare class HelperBlock {
+    protected parent: Element;
+    protected renderer: Renderer2;
+    protected _helper: Element;
+    private _added;
+    constructor(parent: Element, renderer: Renderer2);
+    add(): void;
+    remove(): void;
+    dispose(): void;
+    get el(): Element;
+}