wuic-framework-lib 0.0.1

package/lib/directive/helpers/ngx-draggable-dom-math.d.ts

@@ -0,0 +1,65 @@
+import { NgxDraggablePoint } from '../classes/ngx-draggable-point';
+export declare enum ElementHandle {
+    TL = "tl",
+    TR = "tr",
+    BL = "bl",
+    BR = "br",
+    L = "ml",
+    R = "mr",
+    T = "mt",
+    B = "mb"
+}
+/**
+ * Helper functions that are used to help with various mathematical calculations.
+ */
+export declare class NgxDraggableMath {
+    /**
+     * Determines if a given point resides inside of the bounds rectangle that is also provided. This determination is
+     * calculated within a zero degree orientation coordinate space, therefore, the bounds rectangle that is provided
+     * should already be in a normalized size when provided.
+     *
+     * Also, please note that this logic will treat the one pixel edge of the bounds rectangle as being outside of the
+     * boundaries for the purpose of analyzing boundaries.
+     *
+     * @param point The point to check.
+     * @param bounds The boundaries that define where we want to check where the point resides.
+     * @return True if the point resides within the bounds.
+     */
+    static isPointInsideBounds(point: NgxDraggablePoint, bounds: DOMRect): boolean;
+    /**
+     * Rotates a given NgxDraggablePoint around another pivot NgxDraggablePoint.
+     *
+     * @param point The point to be rotated.
+     * @param pivot The pivot point that we are rotating the NgxDraggablePoint, point, around.
+     * @param angle The angle at which we want to rotate the NgxDraggablePoint, point, around the pivot point.
+     */
+    static rotatePoint(point: NgxDraggablePoint, pivot: NgxDraggablePoint, angle: number): NgxDraggablePoint;
+    /**
+     * Calculates the linear distance between two provided points.
+     *
+     * @param p0 The first point.
+     * @param p1 The second point.
+     */
+    static getDistanceBetweenPoints(p0: NgxDraggablePoint, p1: NgxDraggablePoint): number;
+    /**
+     * Find the coordinate point of the bounding box as defined by w and h and rotated by rotation degrees around point p0.
+     *
+     * @param p0 The center point of origin we are rotating around.
+     * @param w The width of the bounding box we are calculating.
+     * @param h The height of the bounding box we are calculating.
+     * @param rotation The degrees of rotation being applied to the box.
+     * @param coordinate The coordinate you would like "tl", "t", "tr", "r", "br", "b", "bl", "l"
+     * @return The requested point.
+     */
+    static getTransformedCoordinate(p0: NgxDraggablePoint, w: number, h: number, rotation: number, coordinate?: ElementHandle): NgxDraggablePoint | null;
+    /**
+     * Calculates the bounding box for a given element defined by a center point, width, height, and rotation.
+     *
+     * @param p0 The center of the object that we need to find the bounding box for.
+     * @param w The width of the rectangle.
+     * @param h The height of the rectangle.
+     * @param rotation The rotation of the defined rectangle.
+     * @return The bounding box rectangle.
+     */
+    static getBoundingBox(p0: NgxDraggablePoint, w: number, h: number, rotation: number): DOMRect | null;
+}

package/lib/directive/helpers/ngx-draggable-dom-utilities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Helper functions that are used to traverse the DOM and perform other helpful tasks.
+ */
+export declare class NgxDraggableDomUtilities {
+    /**
+     * Calculates the computed transform matrix for a given element.
+     *
+     * @param el The html element that we want to find the computed transform matrix for.
+     * @return The computed transform matrix as an array of numbers.
+     */
+    static getTransformMatrixForElement(el: HTMLElement): number[];
+    /**
+     * Calculates the current rotation (in degrees) for a given HTMLElement using the computed transform style.
+     *
+     * @param el The HTMLElement to find the current rotation for.
+     */
+    static getRotationForElement(el: HTMLElement): number;
+    /**
+     * Finds the overall computed rotation of the element including parent nodes so we can get an accurate
+     * reading on the visual rotation of the element so we can appropriately adjust matrix translation
+     * adjustments.
+     *
+     * @return The overall rotation of all parent nodes.
+     */
+    static getTotalRotationForElement(node: HTMLElement | null, rotation?: number): number;
+}

package/lib/directive/helpers/resize-handle.d.ts

@@ -0,0 +1,14 @@
+import { Renderer2 } from '@angular/core';
+export declare class ResizeHandle {
+    protected parent: Element;
+    protected renderer: Renderer2;
+    type: string;
+    css: string;
+    private onMouseDown;
+    private existHandle?;
+    protected _handle: Element;
+    private _onResize;
+    constructor(parent: Element, renderer: Renderer2, type: string, css: string, onMouseDown: any, existHandle?: Element);
+    dispose(): void;
+    get el(): Element;
+}

package/lib/directive/models/position.d.ts

@@ -0,0 +1,21 @@
+export interface IPosition {
+    x: number;
+    y: number;
+}
+export declare class Position implements IPosition {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    static fromEvent(e: MouseEvent | TouchEvent, el?: any): Position;
+    static isMouseEvent(e: MouseEvent | TouchEvent): e is MouseEvent;
+    static isIPosition(obj: any): obj is IPosition;
+    static getCurrent(el: Element): Position;
+    static copy(p: IPosition): Position;
+    get value(): IPosition;
+    add(p: IPosition): this;
+    subtract(p: IPosition): this;
+    multiply(n: number): void;
+    divide(n: number): void;
+    reset(): this;
+    set(p: IPosition): this;
+}

package/lib/directive/models/resize-event.d.ts

@@ -0,0 +1,16 @@
+import { ISize } from './size';
+export interface IResizeEvent {
+    host: any;
+    handle: any;
+    size: ISize;
+    position: {
+        top: number;
+        left: number;
+    };
+    direction: {
+        n: boolean;
+        s: boolean;
+        w: boolean;
+        e: boolean;
+    };
+}

package/lib/directive/models/resize-handle-type.d.ts

@@ -0,0 +1,11 @@
+export interface ResizeHandleStyle {
+    n?: string;
+    s?: string;
+    e?: string;
+    w?: string;
+    ne?: string;
+    nw?: string;
+    se?: string;
+    sw?: string;
+}
+export type ResizeHandleType = string | ResizeHandleStyle;

package/lib/directive/models/size.d.ts

@@ -0,0 +1,12 @@
+export interface ISize {
+    width: number;
+    height: number;
+}
+export declare class Size implements ISize {
+    width: number;
+    height: number;
+    constructor(width: number, height: number);
+    static getCurrent(el: Element): Size;
+    static copy(s: Size): Size;
+    set(s: ISize): this;
+}

package/lib/directive/ngx-draggable-dom.directive.d.ts

@@ -0,0 +1,175 @@
+import { ChangeDetectorRef, ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgxDraggableDomDirective {
+    private el;
+    private renderer;
+    private changeRef;
+    private static MAX_SAFE_Z_INDEX;
+    bounds: HTMLElement | undefined;
+    constrainByBounds: boolean;
+    handle: HTMLElement | undefined;
+    requireMouseOver: boolean;
+    requireMouseOverBounds: boolean;
+    ignoreMultiTouchEvents: boolean;
+    private started;
+    private stopped;
+    private moved;
+    private edge;
+    private allowDrag;
+    private moving;
+    private computedRotation;
+    private startPosition;
+    private pickUpOffset;
+    private oldZIndex;
+    private oldPosition;
+    private fnMouseMove;
+    private fnTouchMove;
+    private fnMouseUp;
+    private fnTouchEnd;
+    /**
+     * Read only property that returns the width of the element in a normalized 0 degree rotation orientation.
+     *
+     * @return The true width of the element.
+     */
+    private get elWidth();
+    /**
+     * Read only property that returns the height of the element in a normalized 0 degree rotation orientation.
+     *
+     * @return The true height of the element.
+     */
+    private get elHeight();
+    /**
+     * Calculates and returns the element's center point based on the element's bounding rectangle.
+     *
+     * @return A NgxDraggablePoint that represents the center point of the element.
+     */
+    private get elCenter();
+    /**
+     * Calculates and returns the bounds' center point based on the bounding element's bounding rectangle.
+     *
+     * @return A NgxDraggablePoint that represents the center point of the bounds.
+     */
+    private get boundsCenter();
+    /**
+     * Read only property that calculates the left scroll position of the document.
+     *
+     * @return The current scroll position of the document in the x direction.
+     */
+    private get scrollLeft();
+    /**
+     * Read only property that calculates the top scroll position of the document.
+     *
+     * @return The current scroll position of the document in the y direction.
+     */
+    private get scrollTop();
+    /**
+     * Controls the draggable behavior of the element that the NgxDraggableDirective is applied to.
+     *
+     * @return True if the element is draggable.
+     */
+    get ngxDraggableDom(): boolean;
+    /**
+     * Controls the draggable behavior of the element that the NgxDraggableDirective is applied to.
+     *
+     * @param enabled Whether the draggable behavior should be turned on or off.
+     */
+    set ngxDraggableDom(enabled: boolean);
+    constructor(el: ElementRef, renderer: Renderer2, changeRef: ChangeDetectorRef);
+    /**
+     * Event handler for when the element starts moving via mouse interaction.
+     *
+     * @param event The mouse event for the click event.
+     */
+    private onMouseDown;
+    /**
+     * Event handler for when the mouse leaves the element so the drag event ends.
+     *
+     * @param event The mouse event for when the mouse leaves the element.
+     */
+    private onMouseLeave;
+    /**
+     * Event handler for when the element starts moving via a touch event.
+     *
+     * @param event The touch event to handle as a TouchEvent (or any solely for working around issues with Safari).
+     */
+    private onTouchStart;
+    /**
+     * Angular lifecycle hook for initialization that ensures that the draggable class is applied to the element.
+     */
+    ngOnInit(): void;
+    /**
+     * Resets the state of the element. This will reset all positioning and movement data
+     * but will not modify the current state of any data bound properties.
+     */
+    reset(): void;
+    /**
+     * Invoked the Angular change detector to ensure that changes to the element's styling are reflected in the view.
+     */
+    private ngDetectChanges;
+    /**
+     * Event handler for when the element is done being dragged as indicated by a mouse release.
+     *
+     * @param event The mouse event for the click release event.
+     */
+    private onMouseUp;
+    /**
+     * Event handler for when the mouse moves. If the element is currently picked up, then we will apply transformations
+     * to the element to move it.
+     *
+     * @param event The mouse event for the movement from the user's mouse.
+     */
+    private onMouseMove;
+    /**
+     * Event handler for when the element is done being moved via a touch event.
+     *
+     * @param event The touch event to handle as a TouchEvent (or any solely for working around issues with Safari).
+     */
+    private onTouchEnd;
+    /**
+     * Event handler for when the element is moved via a touch event.
+     *
+     * @param event The touch event to handle as a TouchEvent (or any solely for working around issues with Safari).
+     */
+    private onTouchMove;
+    /**
+     * Checks to see if a given point, that should represent the user's mouse position, resides within
+     * the bounds if they are defined and we are both checking for bounds constraints and if we are configured
+     * to hold the object steady when constrained and the cursor is outside of the bounds.
+     *
+     * @param point The point to check to see if it is inside of the boundaries
+     */
+    private allowMovementForPosition;
+    /**
+     * Moves the element to a specified coordinate and performs any necessary boundary checking.
+     *
+     * @param x The x position to move the element to.
+     * @param y The y position to move the element to.
+     */
+    private moveTo;
+    /**
+     * Puts the element into a state of being moved setting appropriate styles and firing movement events when
+     * the element is just beginning to move. Here is where the start position and pick up offset is calculated.
+     *
+     * @param event The pick up event that will either be a mouse event or touch event.
+     */
+    private pickUp;
+    /**
+     * Puts the element down following some movement. This will fire the stopped event to signal that
+     * dragging is complete if we are configured to do so.
+     *
+     * @param fireEvents When set to true, the operation of putting an element back will fire the movement event.
+     */
+    private putBack;
+    /**
+     * Uses the defined boundary element and checks for an intersection with the draggable element to determine
+     * if any edge has collided with one another. If the edge is collided and we are constraining, we calculate a new translation value
+     * and constrained center point so we can position the element reliably within the bounds.
+     *
+     * @param elP0 The center point of the element position that boundaries should be checked on.
+     * @param isSecondaryBoundsCheck Optional parameter that indicates whether we are the secondary bounds check.
+     * @return A NgxDraggableDomBoundsCheckEvent indicating which boundary edges were violated or null if boundary check is disabled.
+     */
+    private boundsCheck;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDraggableDomDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDraggableDomDirective, "[ngxDraggableDom]", never, { "bounds": { "alias": "bounds"; "required": false; }; "constrainByBounds": { "alias": "constrainByBounds"; "required": false; }; "handle": { "alias": "handle"; "required": false; }; "requireMouseOver": { "alias": "requireMouseOver"; "required": false; }; "requireMouseOverBounds": { "alias": "requireMouseOverBounds"; "required": false; }; "ignoreMultiTouchEvents": { "alias": "ignoreMultiTouchEvents"; "required": false; }; "ngxDraggableDom": { "alias": "ngxDraggableDom"; "required": false; }; }, { "started": "started"; "stopped": "stopped"; "moved": "moved"; "edge": "edge"; }, never, never, true, never>;
+}

package/lib/handler/GlobalHandler.d.ts

@@ -0,0 +1,11 @@
+import { ErrorHandler } from "@angular/core";
+import { CustomException } from "../class/customException";
+import { BehaviorSubject } from "rxjs";
+export declare class GlobalHandler implements ErrorHandler {
+    static messageNotification: BehaviorSubject<{
+        show: boolean;
+        exception: CustomException;
+    }>;
+    constructor();
+    handleError(e: any): void;
+}

package/lib/handler/mime.d.ts

@@ -0,0 +1,11 @@
+export declare class mime {
+    static types: {
+        [key: string]: {
+            source?: string;
+            compressible?: boolean;
+            charset?: string;
+            extensions?: string[];
+        };
+    };
+    static getType(filename: string, mimeType: string): string;
+}

package/lib/pipe/async-callback.pipe.d.ts

@@ -0,0 +1,11 @@
+import { Injector, OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AsyncCallbackPipe implements PipeTransform, OnDestroy {
+    private injector;
+    private asyncPipe;
+    constructor(injector: Injector);
+    ngOnDestroy(): void;
+    transform(record: any, ...args: any[]): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncCallbackPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsyncCallbackPipe, "asyncCallback", true>;
+}

package/lib/pipe/available-operators.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { MetadatiColonna } from '../class/metadati_colonna';
+import * as i0 from "@angular/core";
+export declare class AvailableOperatorsPipe implements PipeTransform {
+    transform(operators: any[], field: MetadatiColonna): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvailableOperatorsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AvailableOperatorsPipe, "availableOperators", true>;
+}

package/lib/pipe/callback.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CallbackPipe implements PipeTransform {
+    transform(items: any[], callback: (item: any) => boolean, field?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CallbackPipe, "callback", true>;
+}

package/lib/pipe/callback2.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CallbackPipe2 implements PipeTransform {
+    transform(items: any[], callback: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackPipe2, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CallbackPipe2, "callback2", true>;
+}

package/lib/pipe/format-grid-view-value.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { MetadatiColonna } from '../class/metadati_colonna';
+import * as i0 from "@angular/core";
+export declare class FormatGridViewValuePipe implements PipeTransform {
+    transform(rowData: unknown, metaColumn: MetadatiColonna): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatGridViewValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatGridViewValuePipe, "formatGridViewValue", true>;
+}

package/lib/pipe/get-src-upload-preview.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { MetadatiColonna } from '../class/metadati_colonna';
+import { MetaInfo } from '../class/metaInfo';
+import * as i0 from "@angular/core";
+export declare class GetSrcUploadPreviewPipe implements PipeTransform {
+    transform(value: string, UploadField: MetadatiColonna, metaInfo: MetaInfo, record: any, thumb?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetSrcUploadPreviewPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GetSrcUploadPreviewPipe, "getSrcUploadPreview", true>;
+}

package/lib/pipe/is-selected-row.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { MetaInfo } from '../class/metaInfo';
+import * as i0 from "@angular/core";
+export declare class IsSelectedRowPipe implements PipeTransform {
+    transform(items: any[], rowData: any, metaInfo: MetaInfo): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsSelectedRowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsSelectedRowPipe, "isSelectedRow", true>;
+}

package/lib/pipe/prop-converter.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PropConverterPipe implements PipeTransform {
+    transform(value: unknown, ...args: unknown[]): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropConverterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PropConverterPipe, "propConverter", true>;
+}

package/lib/pipe/show-filter-bar.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { BoundedRepeaterComponent } from '../component/bounded-repeater/bounded-repeater.component';
+import { MetadatiColonna } from '../class/metadati_colonna';
+import * as i0 from "@angular/core";
+export declare class ShowFilterBarPipe implements PipeTransform {
+    transform(columnMetadata: MetadatiColonna[], repeater: BoundedRepeaterComponent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowFilterBarPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ShowFilterBarPipe, "showFilterBar", true>;
+}

package/lib/pipe/to-date.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ToDatePipe implements PipeTransform {
+    transform(value: string, ...args: unknown[]): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToDatePipe, "toDate", true>;
+}

package/lib/pipe/visible-field-list.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class VisibleFieldListPipe implements PipeTransform {
+    transform(value: any[], ...args: any): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisibleFieldListPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<VisibleFieldListPipe, "visibleFieldList", true>;
+}

package/lib/service/auth-session.service.d.ts

@@ -0,0 +1,52 @@
+import { HttpClient } from '@angular/common/http';
+import { MetadataProviderService } from './metadata-provider.service';
+import { UserInfoService } from './user-info.service';
+import * as i0 from "@angular/core";
+export interface AuthSessionState {
+    initialized: boolean;
+    loading: boolean;
+    enabled: boolean;
+    authenticated: boolean;
+    legacyAuthenticated: boolean;
+    provider?: string;
+    name?: string;
+    legacyName?: string;
+    legacyRole?: string;
+    claims?: {
+        type: string;
+        value: string;
+    }[];
+    error?: string;
+    returnUrl: string;
+}
+export declare class AuthSessionService {
+    private http;
+    private userInfoService;
+    private metadataProvider;
+    private initialized;
+    private readonly stateSubject;
+    readonly state$: import("rxjs").Observable<AuthSessionState>;
+    get snapshot(): AuthSessionState;
+    constructor(http: HttpClient, userInfoService: UserInfoService, metadataProvider: MetadataProviderService);
+    initialize(force?: boolean): Promise<void>;
+    refreshAll(): Promise<void>;
+    setReturnUrl(returnUrl: string): void;
+    login(returnUrl?: string): void;
+    logout(returnUrl?: string): void;
+    legacyLogin(username: string, password: string): Promise<boolean>;
+    legacyLogout(): Promise<void>;
+    private bootstrapUserCustomSettings;
+    private patchState;
+    private buildEndpoint;
+    private buildMetaAsmxEndpoint;
+    private getApiBaseUrl;
+    private isOAuthEnabledInSettings;
+    private normalizeReturnUrl;
+    private getCurrentLocalUrl;
+    private parseLegacyLoginResponse;
+    private extractLegacyLoginError;
+    private readMessage;
+    private debugLegacyLogin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthSessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthSessionService>;
+}

package/lib/service/client-side-crud.service.d.ts

@@ -0,0 +1,35 @@
+import { DataSourceComponent } from '../component/data-source/data-source.component';
+import { ResultInfo } from '../class/resultInfo';
+import * as i0 from "@angular/core";
+export declare class ClientSideCrudService {
+    private db;
+    private readonly localModePrefix;
+    private clone;
+    private normalizeRoute;
+    private normalizeUserId;
+    private getRoute;
+    private getPkName;
+    private getPkValue;
+    private findRow;
+    private getTempPk;
+    private getModeKey;
+    private setModeEnabled;
+    isModeEnabled(scope: DataSourceComponent, userId: string | number): Promise<boolean>;
+    enable(scope: DataSourceComponent, userId: string | number, allRows: any[]): Promise<void>;
+    select(scope: DataSourceComponent, userId: string | number, all: boolean, resultInfo?: ResultInfo): Promise<ResultInfo>;
+    insert(entity: any, scope: DataSourceComponent, userId: string | number): Promise<any>;
+    update(entity: any, scope: DataSourceComponent, userId: string | number): Promise<any>;
+    delete(entity: any, scope: DataSourceComponent, userId: string | number): Promise<any>;
+    disableAndSync(scope: DataSourceComponent, userId: string | number, remote: {
+        insert: (entity: any) => Promise<any>;
+        update: (entity: any) => Promise<any>;
+        delete: (entity: any) => Promise<any>;
+    }): Promise<{
+        inserted: number;
+        updated: number;
+        deleted: number;
+    }>;
+    clearRoute(scope: DataSourceComponent, userId: string | number): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientSideCrudService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientSideCrudService>;
+}

package/lib/service/data-provider-meta.service.d.ts

@@ -0,0 +1,32 @@
+import { DataSourceComponent } from '../component/data-source/data-source.component';
+import { ComboParams } from '../class/comboParams';
+import { MetadatiColonna } from '../class/metadati_colonna';
+import { rawPagedResult } from '../class/rawPagedResult';
+import { ResultInfo } from '../class/resultInfo';
+import { HttpClient } from '@angular/common/http';
+import { FilterInfo } from '../class/filterInfo';
+import { SortInfo } from '../class/sortInfo';
+import * as i0 from "@angular/core";
+export declare class DataProviderMetaService {
+    private _http;
+    http: HttpClient;
+    constructor(_http: HttpClient);
+    select(scope: DataSourceComponent, userId: number, all: boolean, resultInfo?: ResultInfo, hideBusy?: any): Promise<ResultInfo>;
+    selectByRoute(userId: number, route: string, filterInfo?: FilterInfo, sortInfo?: SortInfo[], pageSize?: number, currentPage?: number): Promise<ResultInfo>;
+    getComboData(scope: ComboParams, UserInfo: any, currentRecord: any, field: MetadatiColonna, filterString: string): Promise<rawPagedResult>;
+    update(entity: any, pristine: any, scope: DataSourceComponent, UserInfo: any): Promise<any>;
+    insert(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    clone(entity: any, scope: DataSourceComponent, userId: number, relatedRouteToClone: any[]): Promise<any>;
+    delete(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    saveDashboard(payload: any): Promise<any>;
+    loadDashboard(payload: any): Promise<any[]>;
+    saveWorkflowGraph(payload: any): Promise<any>;
+    loadWorkflowGraph(payload: any): Promise<any>;
+    getWorkflowGraphs(payload: any): Promise<any>;
+    renameWorkflowGraph(payload: any): Promise<any>;
+    deleteWorkflowGraph(payload: any): Promise<any>;
+    getCssClassesFromSheets(sheetPaths: string[]): Promise<any[]>;
+    writeChangesToCssFile(sheet: any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataProviderMetaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataProviderMetaService>;
+}

package/lib/service/data-provider-odata.service.d.ts

@@ -0,0 +1,18 @@
+import { DataSourceComponent } from '../component/data-source/data-source.component';
+import { ResultInfo } from '../class/resultInfo';
+import { HttpClient } from '@angular/common/http';
+import { FilterInfo } from '../class/filterInfo';
+import * as i0 from "@angular/core";
+export declare class DataProviderOdataService {
+    private http;
+    constructor(http: HttpClient);
+    select(scope: DataSourceComponent, userId: number, all: boolean, resultInfo?: ResultInfo, hideBusy?: any): Promise<ResultInfo>;
+    filterInfoToOdata(filterInfo: FilterInfo, route: string): string;
+    getOdataOperator(operatore: string, value?: any): string;
+    update(entity: any, pristine: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    insert(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    clone(entity: any, scope: DataSourceComponent, userId: number, relatedRouteToClone: any[]): Promise<any>;
+    delete(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataProviderOdataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataProviderOdataService>;
+}

package/lib/service/data-provider-webservice.service.d.ts

@@ -0,0 +1,15 @@
+import { DataSourceComponent } from '../component/data-source/data-source.component';
+import { ResultInfo } from '../class/resultInfo';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class DataProviderWebserviceService {
+    private http;
+    constructor(http: HttpClient);
+    select(scope: DataSourceComponent, userId: number, all: boolean, resultInfo?: ResultInfo, hideBusy?: any): Promise<ResultInfo>;
+    update(entity: any, pristine: any, scope: DataSourceComponent, UserInfo: any): Promise<any>;
+    insert(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    clone(entity: any, scope: DataSourceComponent, userId: number, relatedRouteToClone: any[]): Promise<any>;
+    delete(entity: any, scope: DataSourceComponent, userId: number): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataProviderWebserviceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataProviderWebserviceService>;
+}