@colijnit/corecomponents_v12 255.1.1 → 255.1.3

package/lib/core/utils/number-utils.d.ts

@@ -0,0 +1,89 @@
+import { CheckWithinSteppedBoundsResult } from "../model/check-within-stepped-bounds-result";
+import { CheckPrecisionAndScaleResult } from '../model/check-precision-and-scale-result';
+export declare class NumberUtils {
+    static PrecisionScaleToMaxValue(precision: number, scale: number): number;
+    static ParseInt(arg: any): number;
+    static DecimalsToStepIncrement(numberOfDecimals: number): number;
+    static ParseNumberOrDefault(arg: any, defaultValue?: number): number;
+    static ParseNumberInputOrDefault(numberInput: any, defaultValue?: number): number;
+    static IsParsableNumberInput(numberInput: any): boolean;
+    static IsNumber(arg: any): boolean;
+    static IsParsableNumber(arg: any): boolean;
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param The argument to parse to a float
+     * @param The number of decimals, or the precision, the parsed return float should have
+     * @returns NaN if not possible, else the parsed float value
+     */
+    static ParseFloat(arg: any, decimalPrecision?: number): number;
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param The argument to parse to a float
+     * @returns The argument as a float with its original decimal precision intact
+     */
+    static ParseFloatKeepPrecision(arg: any): number;
+    static ParseFloatNumberInputKeepPrecision(arg: any): number;
+    /**
+     * Finds the number closest to the originalNumber, that adheres to the given bounds. That is, for which it holds that
+     * nr = min + N * step with N integer or 0.
+     * @param originalNr Find closest answer to this number
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns The closest OK number for bounds.
+     */
+    static GetNearestNumberWithinSteppedBounds(originalNr: number, min: number, max: number, stepSize?: number): number;
+    static GetDecimalPlaces(arg: any, maxAnswer?: number): number;
+    static IsInteger(arg: any): boolean;
+    /**
+     * Returns whether given arg is parseable as a number, and whether the lengts of its number parse result is equal to its original length.
+     * I.e. this function returns FALSE with given number-parsable strings, but that have non-numeric appendices, eg '2233ff'. That arg
+     * IS number-parseable, but not a strict 'string number', the latter being what this method actually checks for.
+     */
+    static IsStringNumber(arg: string): boolean;
+    /**
+     * Returns a random integer in range [lowerBound .. upperBound], an inclusive range. Returns NaN if not possible.
+     * Given bounds are truncated first, before serving as the true lower- and upper bounds for the random int.
+     */
+    static RandomInt(lowerBoundInt: number, upperBoundInt: number): number;
+    /**
+     * Returns the true maximum allowed value for the given "stepped bounds": min, stepSize and max, for which it holds that each allowed
+     * value Y = min + stepSize * N, for any INTEGER or 0 N where it also holds, of course, that Y <= max.
+     * @param min
+     * @param max
+     * @param stepSize
+     */
+    static GetTrueSteppedBoundsMax(min: number, max: number, stepSize?: number): number;
+    static ToString(nr: number): string;
+    static IsNaN(arg: any): boolean;
+    /**
+     * Returns whether given x is OK within the given min, max and step boundaries, where it should hold that nrToCheck = min + N * step,
+     * with N integer or 0.
+     * @param nrToCheck Number to check whether it's within the given bounds
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns Returns remainder of undefined when nrToCheck was OUTSIDE [min, max], else full result object.
+     */
+    static CheckWithinSteppedBounds(nrToCheck: number, min: number, max: number, stepSize?: number): CheckWithinSteppedBoundsResult;
+    static AddThousandsCommasTo(value: any): string;
+    static GetNearestNumberWithinBounds(originalNr: number, min: number, max: number): number;
+    /**
+     * Returns whether given nrToCheck is within the given precision and scale limits. Precision and scale, here, are Oracle DB terms.
+     * This function can thus be used to check whether the given number is safe to send to the 'database' beforehand, if we know the
+     * precision and scale of the number in the db declaration.
+     *
+     * I.e. A number declared in the Oracle DB as number(5, 2) has a precision of 5 and a scale of 2.
+     *
+     * @param nrToCheck
+     * @param precision The number of significant digits, including possibly negative scale. E.g. 3 in '123' and 5 in '51.123'
+     * @param [scale = 0] The number of significant digits AFTER the decimal point. E.g. 1 in 5432.1 and 3 in 54000.003
+     * @returns Whether given nrToCheck is ok for given precision and scale, and if not, the
+     * nearest number that IS ok for those constraints.
+     */
+    static CheckPrecisionAndScale(nrToCheck: number, precision: number, scale?: number): CheckPrecisionAndScaleResult;
+    private static _GetLargestDecimalPrecisionOf;
+    private static _NumberInputToNumberStr;
+}

package/lib/core/utils/object-utils.d.ts

@@ -0,0 +1,31 @@
+export declare class ObjectUtils {
+    /**
+     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
+     * @param values Rest parameters with all objects to check existence for.
+     * @returns True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
+     */
+    static AllExist(...values: any[]): boolean;
+    static GetShallowClone(originalObject: any, objectClass?: any): any;
+    /**
+     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
+     * Does not copy functions, only properties.
+     * @param from The source object from which to copy all properties of to the 'to' object.
+     * @param to The object to which the properties of the 'from' object will be copied.
+     * @param [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
+     */
+    static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined?: boolean): T;
+    /**
+     * Returns the display value of the given property on the given object, as a string (== the string representation of the property value).
+     * Does not return null or undefined, but returns the given defaultValue instead.
+     */
+    static GetDisplayValueOfPropertyOn(object: Object, property: string, defaultValue?: string): string;
+    static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void;
+    static IsPlainObject(object: any): boolean;
+    static DeepEquals(actual: any, expected: any): boolean;
+    private static _objEquiv;
+    private static _isBuffer;
+    private static _isArguments;
+    private static _isArgumentsWhenArgsClassNotSupported;
+    private static _isArgumentsWhenArgsClassSupported;
+    private static _supportsArgumentsClass;
+}

package/lib/core/utils/string-utils.d.ts

@@ -0,0 +1,25 @@
+export declare class StringUtils {
+    static ParseString(arg: any, defaultValue?: string): string;
+    static AsLowerCaseIfString(str: any): any;
+    /**
+     * Example usage:
+     * str = 'File is to large to upload. Maximum file size is {0} Mb'
+     * format = [FileUtils.MaxUploadSizeInMb]
+     * output = File is to large to upload. Maximum file size is 3 Mb
+     *
+     * str = '{0} is way better than {1}'
+     * format = ['Angular2','Angular1']
+     * output = Angular2 is way better than Angular1
+     *
+     * @param str The string that contains {0} and {1} etc, for replacement by given format data
+     * @param format The format replacement data
+     */
+    static Format(str: string, format: any[]): string;
+    static IsString(str: any): boolean;
+    static IsStringWithLength(str: any): boolean;
+    static RemoveLastChars(str: string, amount: number): string;
+    static StringToStringArray(str: string): string[];
+    static CloneStringArray(strArray: string[]): string[];
+    static ToStringOrDefault(arg: any, defaultReturnVal?: string): string;
+    static CreateGuid(): string;
+}

package/lib/core/validator/email.validator.d.ts

@@ -0,0 +1,2 @@
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+export declare function emailValidator(control: AbstractControl): ValidationErrors | null;

package/lib/core/validator/equal.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidatorFn } from "@angular/forms";
+export declare function equalValidator(valueGetterFn: () => any): ValidatorFn;

package/lib/core/validator/max-string-length.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidatorFn } from '@angular/forms';
+export declare function maxStringLengthValidator(length: number): ValidatorFn;

package/lib/core/validator/password.validator.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFn } from "@angular/forms";
+export declare function passwordValidator(userNameGetterFn: () => string): ValidatorFn;
+export declare function getValidatePasswordErrorString(password: string, username: string): string;

package/lib/core/validator/precision-scale.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidatorFn } from '@angular/forms';
+export declare function precisionScaleValidator(precision: number, scale: number): ValidatorFn;

package/lib/core/validator/required.validator.d.ts

@@ -0,0 +1,2 @@
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+export declare function requiredValidator(control: AbstractControl): ValidationErrors | null;

package/lib/directives/clickoutside/click-outside-master.service.d.ts

@@ -0,0 +1,15 @@
+import { NgZone, OnDestroy } from "@angular/core";
+import { ClickOutsideDirective } from "./click-outside.directive";
+export declare class ClickOutsideMasterService implements OnDestroy {
+    private readonly _ngZone;
+    get currentClick(): MouseEvent;
+    private _clickOutsideRefs;
+    private _currentClick;
+    constructor(_ngZone: NgZone);
+    ngOnDestroy(): void;
+    onClick: (event: MouseEvent) => void;
+    checkEmit(clickOutside: ClickOutsideDirective, event: Event, force?: boolean): void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    addClickOutside(clickOutside: ClickOutsideDirective): void;
+    removeClickOutside(clickOutside: ClickOutsideDirective): void;
+}

package/lib/directives/clickoutside/click-outside.directive.d.ts

@@ -0,0 +1,18 @@
+import { AfterViewInit, ElementRef, EventEmitter, NgZone, OnDestroy } from "@angular/core";
+import { ClickOutsideMasterService } from "./click-outside-master.service";
+export declare class ClickOutsideDirective implements OnDestroy, AfterViewInit {
+    elementRef: ElementRef;
+    private _ngZone;
+    private _master;
+    get currentClick(): MouseEvent;
+    set enabled(enabled: boolean);
+    alwaysTrigger: boolean;
+    readonly clickOutside: EventEmitter<Event>;
+    private _currentClick;
+    private _enabled;
+    private _initialized;
+    constructor(elementRef: ElementRef, _ngZone: NgZone, _master: ClickOutsideMasterService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick: (event: MouseEvent) => void;
+}

package/lib/directives/clickoutside/clickoutside.module.d.ts

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

package/lib/directives/observe-visibility/observe-visibility.directive.d.ts

@@ -0,0 +1,14 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+export declare class ObserveVisibilityDirective implements OnDestroy, OnInit, AfterViewInit {
+    private _element;
+    threshold: number;
+    visibilityChange: EventEmitter<boolean>;
+    visible: boolean;
+    private _observer;
+    constructor(_element: ElementRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _createObserver;
+    private _startObservingElements;
+}

package/lib/directives/observe-visibility/observe-visibility.module.d.ts

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

package/lib/directives/overlay/overlay-parent.directive.d.ts

@@ -0,0 +1,6 @@
+import { ElementRef, OnDestroy } from "@angular/core";
+export declare class OverlayParentDirective implements OnDestroy {
+    elementRef: ElementRef;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+}

package/lib/directives/overlay/overlay.directive.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OverlayParentDirective } from './overlay-parent.directive';
+export declare class OverlayDirective implements OnDestroy, OnInit {
+    set parent(value: OverlayParentDirective | ElementRef | HTMLElement);
+    view: HTMLElement;
+    /**
+     * true; Element is added to the parent template
+     * false; Element is added to the bottom of the DOM
+     */
+    inline: boolean;
+    keepInView: boolean;
+    inheritWidth: boolean;
+    rightAlign: boolean;
+    fullSize: boolean;
+    private _elementRef;
+    private _resizeObserver;
+    private _intersectionObserver;
+    private _parent;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    handleScroll: (event: Event) => void;
+    private _checkAndPlaceElement;
+    private _placeElement;
+}

package/lib/directives/overlay/overlay.module.d.ts

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

package/lib/directives/ripple/ripple-ref.d.ts

@@ -0,0 +1,21 @@
+import { CoRippleConfig, CoRippleRenderer } from "./ripple-renderer";
+/** Possible states for a ripple element. */
+export declare enum CoRippleState {
+    FADING_IN = 0,
+    VISIBLE = 1,
+    FADING_OUT = 2,
+    HIDDEN = 3
+}
+/**
+ * Reference to a previously launched ripple element.
+ */
+export declare class CoRippleRef {
+    private _renderer;
+    element: HTMLElement;
+    config: CoRippleConfig;
+    /** Current state of the ripple reference. */
+    state: CoRippleState;
+    constructor(_renderer: CoRippleRenderer, element: HTMLElement, config: CoRippleConfig);
+    /** Fades out the ripple element. */
+    fadeOut(): void;
+}

package/lib/directives/ripple/ripple-renderer.d.ts

@@ -0,0 +1,56 @@
+import { ElementRef, NgZone } from '@angular/core';
+import { CoRippleRef } from "./ripple-ref";
+import { CoViewportRulerService } from "./viewport-ruler.service";
+/** Fade-in duration for the ripples. Can be modified with the speedFactor option. */
+export declare const RIPPLE_FADE_IN_DURATION = 450;
+/** Fade-out duration for the ripples in milliseconds. This can't be modified by the speedFactor. */
+export declare const RIPPLE_FADE_OUT_DURATION = 400;
+export declare type CoRippleConfig = {
+    color?: string;
+    centered?: boolean;
+    radius?: number;
+    speedFactor?: number;
+    persistent?: boolean;
+};
+/**
+ * Helper service that performs DOM manipulations. Not intended to be used outside this module.
+ * The constructor takes a reference to the ripple directive's host element and a map of DOM
+ * event handlers to be installed on the element that triggers ripple animations.
+ * This will eventually become a custom renderer once Angular support exists.
+ * @docs-private
+ */
+export declare class CoRippleRenderer {
+    private _ngZone;
+    private _ruler;
+    /** Element where the ripples are being added to. */
+    private _containerElement;
+    /** Element which triggers the ripple elements on mouse events. */
+    private _triggerElement;
+    /** Whether the mouse is currently down or not. */
+    private _isMousedown;
+    /** Events to be registered on the trigger element. */
+    private _triggerEvents;
+    /** Set of currently active ripple references. */
+    private _activeRipples;
+    /** Ripple config for all ripples created by events. */
+    rippleConfig: CoRippleConfig;
+    /** Whether mouse ripples should be created or not. */
+    rippleDisabled: boolean;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone, _ruler: CoViewportRulerService);
+    /** Fades in a ripple at the given coordinates. */
+    fadeInRipple(pageX: number, pageY: number, config?: CoRippleConfig): CoRippleRef;
+    /** Fades out a ripple reference. */
+    fadeOutRipple(rippleRef: CoRippleRef): void;
+    /** Fades out all currently active ripples. */
+    fadeOutAll(): void;
+    /** Sets the trigger element and registers the mouse events. */
+    setTriggerElement(element: HTMLElement): void;
+    /** Listener being called on mousedown event. */
+    private onMousedown;
+    /** Listener being called on mouseup event. */
+    private onMouseup;
+    /** Listener being called on mouseleave event. */
+    private onMouseLeave;
+    /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
+    private runTimeoutOutsideZone;
+}

package/lib/directives/ripple/ripple.directive.d.ts

@@ -0,0 +1,56 @@
+import { ElementRef, InjectionToken, NgZone, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { CoRippleConfig } from "./ripple-renderer";
+import { CoRippleRef } from "./ripple-ref";
+import { CoViewportRulerService } from "./viewport-ruler.service";
+/** OpaqueToken that can be used to specify the global ripple options. */
+export declare const MD_RIPPLE_GLOBAL_OPTIONS: InjectionToken<CoRippleGlobalOptions>;
+export declare type CoRippleGlobalOptions = {
+    disabled?: boolean;
+    baseSpeedFactor?: number;
+};
+export declare class CoRippleDirective implements OnChanges, OnDestroy {
+    /**
+     * The element that triggers the ripple when click events are received. Defaults to the
+     * directive's host element.
+     */
+    trigger: HTMLElement | HTMLElement;
+    /**
+     * Whether the ripple always originates from the center of the host element's bounds, rather
+     * than originating from the location of the click event.
+     */
+    centered: boolean;
+    /**
+     * Whether click events will not trigger the ripple. It can still be triggered by manually
+     * calling createRipple()
+     */
+    disabled: boolean;
+    /**
+     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
+     * will be the distance from the center of the ripple to the furthest corner of the host element's
+     * bounding rectangle.
+     */
+    radius: number;
+    /**
+     * If set, the normal duration of ripple animations is divided by this value. For example,
+     * setting it to 0.5 will cause the animations to take twice as long.
+     * A changed speedFactor will not modify the fade-out duration of the ripples.
+     */
+    speedFactor: number;
+    /** Custom color for ripples. */
+    color: string;
+    /** Whether foreground ripples should be visible outside the component's bounds. */
+    unbounded: boolean;
+    /** Renderer for the ripple DOM manipulations. */
+    private _rippleRenderer;
+    /** Options that are set globally for all ripples. */
+    private _globalOptions;
+    constructor(elementRef: ElementRef, ngZone: NgZone, ruler: CoViewportRulerService, globalOptions: any);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Launches a manual ripple at the specified position. */
+    launch(pageX: number, pageY: number, config?: CoRippleConfig): CoRippleRef;
+    /** Fades out all currently showing ripple elements. */
+    fadeOutAll(): void;
+    /** Ripple configuration from the directive's input values. */
+    get rippleConfig(): CoRippleConfig;
+}

package/lib/directives/ripple/ripple.module.d.ts

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

package/lib/directives/ripple/scroll-dispatcher.service.d.ts

@@ -0,0 +1,51 @@
+import { ElementRef, Optional } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { CoScrollableDirective } from './scrollable.directive';
+/** Time in ms to throttle the scrolling events by default. */
+export declare const DEFAULT_SCROLL_TIME = 20;
+/**
+ * Service contained all registered Scrollable references and emits an event when any one of the
+ * Scrollable references emit a scrolled event.
+ */
+export declare class CoScrollDispatcherService {
+    /** Subject for notifying that a registered scrollable reference element has been scrolled. */
+    _scrolled: Subject<void>;
+    /** Keeps track of the global `scroll` and `resize` subscriptions. */
+    _globalSubscription: Subscription;
+    /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
+    private _scrolledCount;
+    /**
+     * Map of all the scrollable references that are registered with the service and their
+     * scroll event subscriptions.
+     */
+    scrollableReferences: Map<CoScrollableDirective, Subscription>;
+    /**
+     * Registers a Scrollable with the service and listens for its scrolled events. When the
+     * scrollable is scrolled, the service emits the event in its scrolled observable.
+     * @param scrollable Scrollable instance to be registered.
+     */
+    register(scrollable: CoScrollableDirective): void;
+    /**
+     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
+     * @param scrollable Scrollable instance to be deregistered.
+     */
+    deregister(scrollable: CoScrollableDirective): void;
+    /**
+     * Subscribes to an observable that emits an event whenever any of the registered Scrollable
+     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
+     * to override the default "throttle" time.
+     */
+    scrolled(auditTimeInMs: number, callback: () => any): Subscription;
+    /** Returns all registered Scrollables that contain the provided element. */
+    getScrollContainers(elementRef: ElementRef): CoScrollableDirective[];
+    /** Returns true if the element is contained within the provided Scrollable. */
+    scrollableContainsElement(scrollable: CoScrollableDirective, elementRef: ElementRef): boolean;
+    /** Sends a notification that a scroll event has been fired. */
+    _notify(): void;
+}
+export declare function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher: CoScrollDispatcherService): CoScrollDispatcherService;
+export declare const SCROLL_DISPATCHER_PROVIDER: {
+    provide: typeof CoScrollDispatcherService;
+    deps: Optional[][];
+    useFactory: typeof SCROLL_DISPATCHER_PROVIDER_FACTORY;
+};

package/lib/directives/ripple/scrollable.directive.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { CoScrollDispatcherService } from './scroll-dispatcher.service';
+import { Observable } from 'rxjs';
+/**
+ * Sends an event when the directive's element is scrolled. Registers itself with the
+ * ScrollDispatcher service to include itself as part of its collection of scrolling events that it
+ * can be listened to through the service.
+ */
+export declare class CoScrollableDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _scroll;
+    constructor(_elementRef: ElementRef, _scroll: CoScrollDispatcherService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Returns observable that emits when a scroll event is fired on the host element.
+     */
+    elementScrolled(): Observable<any>;
+    getElementRef(): ElementRef;
+}

package/lib/directives/ripple/viewport-ruler.service.d.ts

@@ -0,0 +1,29 @@
+import { Optional } from '@angular/core';
+import { CoScrollDispatcherService } from "./scroll-dispatcher.service";
+/**
+ * Simple utility for getting the bounds of the browser viewport.
+ * @docs-private
+ */
+export declare class CoViewportRulerService {
+    /** Cached document client rectangle. */
+    private _documentRect?;
+    constructor(scrollDispatcher: CoScrollDispatcherService);
+    /** Gets a ClientRect for the viewport's bounds. */
+    getViewportRect(documentRect?: ClientRect): ClientRect;
+    /**
+     * Gets the (top, left) scroll position of the viewport.
+     * @param documentRect
+     */
+    getViewportScrollPosition(documentRect?: ClientRect): {
+        top: number;
+        left: number;
+    };
+    /** Caches the latest client rectangle of the document element. */
+    _cacheViewportGeometry(): void;
+}
+export declare function VIEWPORT_RULER_PROVIDER_FACTORY(parentRuler: CoViewportRulerService, scrollDispatcher: CoScrollDispatcherService): CoViewportRulerService;
+export declare const VIEWPORT_RULER_PROVIDER: {
+    provide: typeof CoViewportRulerService;
+    deps: (typeof CoScrollDispatcherService | Optional[])[];
+    useFactory: typeof VIEWPORT_RULER_PROVIDER_FACTORY;
+};

package/lib/directives/screen-configuration/screen-configuration.directive.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import { ScreenConfigAdapterComponent } from '../../interfaces/screen-config-adapter.component.interface';
+import { BaseModuleScreenConfigService } from '../../service/base-module-screen-config.service';
+import { BaseModuleService } from '../../service/base-module.service';
+export declare class ScreenConfigurationDirective implements OnDestroy {
+    hostComponent: ScreenConfigAdapterComponent;
+    private _element;
+    private _configService;
+    private _renderer;
+    private _moduleService?;
+    set screenConfigurationObject(value: string);
+    get screenConfigurationObject(): string;
+    dataName: string;
+    screenConfigNativeElement: boolean;
+    noModuleService: boolean;
+    private _isHeader;
+    private _screenConfigurationObject;
+    private _isTurnedOff;
+    private _subs;
+    constructor(hostComponent: ScreenConfigAdapterComponent, _element: ElementRef, _configService: BaseModuleScreenConfigService, _renderer: Renderer2, _moduleService?: BaseModuleService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _updateHost;
+    /**
+     * Spawn error message tooltip onto our host comp, if any error was meant for the host (found by screenConfigurationObject);
+     * @param errorValidation A top-level full validation result, either from the backend or from some client-side validation error.
+     */
+    private _setErrorRedBackgroundAfterScrCfgValidate;
+    private _moduleInReadonlyMode;
+    private _mayUpdateHost;
+    private _setHostVisible;
+}

package/lib/directives/screen-configuration/screen-configuration.module.d.ts

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

package/lib/directives/stopclick/stop-click.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, NgZone, OnDestroy, OnInit } from "@angular/core";
+export declare class StopClickDirective implements OnInit, OnDestroy {
+    private _elementRef;
+    private _ngZone;
+    stopClick: boolean;
+    constructor(_elementRef: ElementRef, _ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _killEventHandler;
+}

package/lib/directives/stopclick/stop-click.module.d.ts

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

package/lib/directives/template-wrapper/template-wrapper.directive.d.ts

@@ -0,0 +1,13 @@
+import { OnChanges, OnDestroy, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
+export declare class TemplateWrapperDirective implements OnDestroy, OnChanges {
+    protected viewContainer: ViewContainerRef;
+    templateWrapper: TemplateRef<any> | null;
+    templateWrapperContext: Object | null;
+    private _viewRef;
+    constructor(viewContainer: ViewContainerRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private _shouldRecreateView;
+    private _hasContextShapeChanged;
+    private _updateExistingContext;
+}

package/lib/directives/template-wrapper/template-wrapper.module.d.ts

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

package/lib/directives/tooltip/tooltip-directive.module.d.ts

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

package/lib/directives/tooltip/tooltip.directive.d.ts

@@ -0,0 +1,20 @@
+import { ApplicationRef, ComponentFactoryResolver, ElementRef, Injector, OnDestroy, OnInit } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+export declare class TooltipDirective implements OnDestroy, OnInit {
+    private _compFactoryResolver;
+    private _appRef;
+    private _injector;
+    private _sanitizer;
+    set tooltip(str: string);
+    private _elementRef;
+    private _tooltipMessage;
+    private _componentRef;
+    constructor(elementRef: ElementRef, _compFactoryResolver: ComponentFactoryResolver, _appRef: ApplicationRef, _injector: Injector, _sanitizer: DomSanitizer);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    private _handleScroll;
+    private _handleMouseMove;
+    private _showTooltip;
+    private _removeTooltip;
+    private _createTooltipComponent;
+}

package/lib/interfaces/dialog-response.interface.d.ts

@@ -0,0 +1,6 @@
+import { AppPopupButtonType } from '../model/enum/app-button-type.enum';
+export interface DialogResponseInterface {
+    button: AppPopupButtonType;
+    output?: any;
+    rememberChoice?: boolean;
+}

package/lib/interfaces/screen-config-adapter-component-interface-name.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from "@angular/core";
+import { ScreenConfigAdapterComponent } from "./screen-config-adapter.component.interface";
+export declare const SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME: InjectionToken<ScreenConfigAdapterComponent>;

package/lib/interfaces/screen-config-adapter.component.interface.d.ts

@@ -0,0 +1,10 @@
+export interface ScreenConfigAdapterComponent {
+    objectConfigName: string;
+    hidden: boolean;
+    required: boolean;
+    forceReadonly: boolean;
+    readonly: boolean;
+    maxLength: number;
+    decimals: number;
+    redErrorBackground: boolean;
+}