@micropermit/client-angular 0.4.4 → 0.4.5-alpha2

package/{fesm2015/micropermit-client-angular.js → fesm2022/micropermit-client-angular.mjs}

@@ -1,30 +1,24 @@
-import { Injectable, Component, Pipe, ChangeDetectorRef, Input, Directive, ViewContainerRef, TemplateRef, ComponentFactoryResolver, EventEmitter, Output, HostListener, forwardRef, NgModule } from '@angular/core';
-import { HttpHeaders, HttpClient, HttpClientModule } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Injectable, Component, Pipe, Input, Directive, EventEmitter, Output, HostListener, forwardRef, NgModule } from '@angular/core';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, provideHttpClient } from '@angular/common/http';
 import { ReplaySubject, defer, throwError, timer, of } from 'rxjs';
 import { take, map, catchError, finalize, switchMap, delay } from 'rxjs/operators';
-import { cloneDeepWith } from 'lodash';
+import * as _ from 'lodash';
 import { AsyncPipe } from '@angular/common';
 import { FormGroup, NG_ASYNC_VALIDATORS } from '@angular/forms';
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class ParamUtils {
-    /**
-     * @param {?} url
-     * @param {?} key
-     * @param {?} value
-     * @param {?=} replaceExisting
-     * @return {?}
-     */
+    static plusRegex = new RegExp('\\+');
+    static slashRegex = new RegExp('/', 'g');
+    static multiEqualRegex = new RegExp('=+$', 'g');
+    static minusRegex = new RegExp('-', 'g');
+    static underscoreRegex = new RegExp('_', 'g');
     static addParam(url, key, value, replaceExisting = true) {
-        /** @type {?} */
         const hasQueryParams = url.indexOf('?') >= 0;
         if (!hasQueryParams) {
             url += '?';
         }
-        /** @type {?} */
         const existingParam = ParamUtils.getParam(url, key);
         if (existingParam != null && replaceExisting) {
             url = url.replace(key + '=' + existingParam, key + '=' + value);
@@ -37,17 +31,9 @@ class ParamUtils {
         }
         return url;
     }
-    /**
-     * @param {?} url
-     * @param {?} params
-     * @return {?}
-     */
     static setParams(url, params) {
-        /** @type {?} */
         const splitted = url.split('?');
-        /** @type {?} */
         let resURL = splitted[0];
-        /** @type {?} */
         let first = true;
         for (const key in params) {
             if (params.hasOwnProperty(key)) {
@@ -60,26 +46,16 @@ class ParamUtils {
         }
         return resURL;
     }
-    /**
-     * @param {?} url
-     * @return {?}
-     */
     static getParams(url) {
-        /** @type {?} */
         const splitted = url.split('?');
         if (splitted.length < 2) {
             return {};
         }
-        /** @type {?} */
         const queryStr = splitted[1];
-        /** @type {?} */
         const params = {};
-        /** @type {?} */
         const paramsStrs = queryStr.split('&');
         for (const paramStr of paramsStrs) {
-            /** @type {?} */
             const splittedParamStr = paramStr.split('=', 2);
-            /** @type {?} */
             const key = splittedParamStr[0];
             if (splittedParamStr.length === 2) {
                 params[key] = splittedParamStr[1];
@@ -90,30 +66,18 @@ class ParamUtils {
         }
         return params;
     }
-    /**
-     * @param {?} toEncode
-     * @return {?}
-     */
     static base64UrlEncode(toEncode) {
         return btoa(toEncode)
             .replace(ParamUtils.plusRegex, '-')
             .replace(ParamUtils.slashRegex, '_')
             .replace(ParamUtils.multiEqualRegex, '');
     }
-    /**
-     * @param {?} toDecode
-     * @return {?}
-     */
     static base64UrlDecode(toDecode) {
         toDecode = (toDecode + '===').slice(0, toDecode.length + (toDecode.length % 4));
         return atob(toDecode
             .replace(ParamUtils.minusRegex, '+')
             .replace(ParamUtils.underscoreRegex, '/'));
     }
-    /**
-     * @param {?} toCheck
-     * @return {?}
-     */
     static needsBase64UrlEncoding(toCheck) {
         if (toCheck == null) {
             return false;
@@ -122,19 +86,10 @@ class ParamUtils {
             return typeof toCheck === 'object';
         }
     }
-    /**
-     * @param {?} url
-     * @param {?} name
-     * @param {?=} urlDecode
-     * @return {?}
-     */
     static getParam(url, name, urlDecode = false) {
-        /** @type {?} */
         const paramsQueryIdx = url.indexOf('?');
         url = url.substr(paramsQueryIdx);
-        /** @type {?} */
         const regExp = (new RegExp('[?&]' + encodeURIComponent(name) + '=([^&]*)'));
-        /** @type {?} */
         const match = regExp.exec(url);
         if (match) {
             if (urlDecode && match[1]) {
@@ -149,97 +104,36 @@ class ParamUtils {
         }
     }
 }
-ParamUtils.plusRegex = new RegExp('\\+');
-ParamUtils.slashRegex = new RegExp('/', 'g');
-ParamUtils.multiEqualRegex = new RegExp('=+$', 'g');
-ParamUtils.minusRegex = new RegExp('-', 'g');
-ParamUtils.underscoreRegex = new RegExp('_', 'g');
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    ParamUtils.plusRegex;
-    /**
-     * @type {?}
-     * @private
-     */
-    ParamUtils.slashRegex;
-    /**
-     * @type {?}
-     * @private
-     */
-    ParamUtils.multiEqualRegex;
-    /**
-     * @type {?}
-     * @private
-     */
-    ParamUtils.minusRegex;
-    /**
-     * @type {?}
-     * @private
-     */
-    ParamUtils.underscoreRegex;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
 class CallableLink {
-    /**
-     * @param {?} link
-     * @param {?} microClient
-     * @param {?=} callParams
-     * @param {?=} requestOptions
-     */
+    link;
+    microClient;
+    callParams;
+    requestOptions;
     constructor(link, microClient, callParams = null, requestOptions = null) {
         this.link = link;
         this.microClient = microClient;
         this.callParams = callParams;
         this.requestOptions = requestOptions;
-        this.serializeTo = LinkSerializer.DONT_SERIALIZE;
     }
-    /**
-     * @return {?}
-     */
+    serializeTo = LinkSerializer.DONT_SERIALIZE;
     hasLink() {
         return this.link != null;
     }
-    /**
-     * @return {?}
-     */
     getLink() {
         return this.link;
     }
-    /**
-     * @param {?} key
-     * @param {?=} urlDecode
-     * @return {?}
-     */
     getQueryParam(key, urlDecode = false) {
         return ParamUtils.getParam(this.link, key, urlDecode);
     }
-    /**
-     * @return {?}
-     */
     getSignedParams() {
-        /** @type {?} */
         let params = this.getSignedMicroObjectParam('params');
         if (params == null) {
             params = this.getSignedMicroObjectParam('bParams');
         }
         return params;
     }
-    /**
-     * @param {?=} copy
-     * @return {?}
-     */
     getOpenParams(copy = false) {
-        /** @type {?} */
         let params = this.getMicroObjectParam('oParams');
         if (params == null) {
             params = this.getMicroObjectParam('bOParams');
@@ -254,11 +148,7 @@ class CallableLink {
         }
         return params;
     }
-    /**
-     * @return {?}
-     */
     getOptions() {
-        /** @type {?} */
         let options = this.getMicroObjectParam('options');
         if (this.requestOptions) {
             if (options == null) {
@@ -268,18 +158,10 @@ class CallableLink {
         }
         return options;
     }
-    /**
-     * @private
-     * @param {?} key
-     * @return {?}
-     */
     getSignedMicroObjectParam(key) {
-        /** @type {?} */
         const paramsStr = ParamUtils.getParam(this.link, key, false);
-        /** @type {?} */
         let params = null;
         if (paramsStr) {
-            /** @type {?} */
             const splitted = paramsStr.split('.');
             if (splitted.length !== 3) {
                 throw new Error('Expected a signed query param to have a JWT like structure');
@@ -288,41 +170,20 @@ class CallableLink {
         }
         return params;
     }
-    /**
-     * @param {?} key
-     * @return {?}
-     */
     getMicroObjectParam(key) {
-        /** @type {?} */
         const paramsStr = ParamUtils.getParam(this.link, key, true);
-        /** @type {?} */
         let params = null;
         if (paramsStr) {
             params = MicroObject.fromString(paramsStr, this.microClient);
         }
         return params;
     }
-    /**
-     * @param {?} onNext
-     * @return {?}
-     */
     call(onNext) {
         return this.callWith(null, null, onNext);
     }
-    /**
-     * @param {?=} params
-     * @param {?=} requestOptions
-     * @param {?=} onNext
-     * @return {?}
-     */
     callWith(params = null, requestOptions = null, onNext) {
-        return (/** @type {?} */ (this.callWithObs(params, requestOptions).toPromise().then(onNext)));
+        return this.callWithObs(params, requestOptions).toPromise().then(onNext);
     }
-    /**
-     * @param {?=} params
-     * @param {?=} requestOptions
-     * @return {?}
-     */
     callWithObs(params = null, requestOptions = null) {
         if (this.link == null) {
             throw Error('Can\'t use callWithObs without a provided link');
@@ -330,7 +191,6 @@ class CallableLink {
         if (this.microClient == null) {
             throw Error('Can\'t use callWithObs without a provided microClient');
         }
-        /** @type {?} */
         let paramsToUse = null;
         if (this.callParams != null) {
             paramsToUse = Object.assign(new MicroObject(), this.callParams);
@@ -341,7 +201,6 @@ class CallableLink {
             }
             paramsToUse = Object.assign(paramsToUse, params);
         }
-        /** @type {?} */
         let optionsToUse = null;
         if (this.requestOptions != null) {
             optionsToUse = Object.assign(new MicroObject(), this.requestOptions);
@@ -352,25 +211,14 @@ class CallableLink {
             }
             optionsToUse = Object.assign(optionsToUse, requestOptions);
         }
-        return (/** @type {?} */ (this.microClient.load(this.link, paramsToUse, optionsToUse)));
+        return this.microClient.load(this.link, paramsToUse, optionsToUse);
     }
-    /**
-     * @return {?}
-     */
     copy() {
         return new CallableLink(this.link, this.microClient, this.callParams, this.requestOptions);
     }
-    /**
-     * @param {?} callParams
-     * @param {?=} requestOptions
-     * @return {?}
-     */
     withCallParams(callParams, requestOptions = this.requestOptions) {
         return new CallableLink(this.link, this.microClient, callParams, requestOptions);
     }
-    /**
-     * @return {?}
-     */
     toJSON() {
         if (this.serializeTo) {
             return this.serializeTo(this.link, this.callParams, this.requestOptions, undefined, undefined);
@@ -380,109 +228,39 @@ class CallableLink {
         }
     }
 }
-if (false) {
-    /** @type {?} */
-    CallableLink.prototype.serializeTo;
-    /**
-     * @type {?}
-     * @protected
-     */
-    CallableLink.prototype.link;
-    /**
-     * @type {?}
-     * @protected
-     */
-    CallableLink.prototype.microClient;
-    /**
-     * @type {?}
-     * @protected
-     */
-    CallableLink.prototype.callParams;
-    /**
-     * @type {?}
-     * @protected
-     */
-    CallableLink.prototype.requestOptions;
-}
 // @dynamic
 class LinkSerializer {
-}
-LinkSerializer.DONT_SERIALIZE = (/**
- * @return {?}
- */
-function () {
-    return undefined;
-});
-LinkSerializer.AS_LINK = (/**
- * @param {?} link
- * @return {?}
- */
-function (link) {
-    return link;
-});
-LinkSerializer.AS_VALUE_IF_INITIALIZED = (/**
- * @param {?} link
- * @param {?} callParams
- * @param {?} requestOptions
- * @param {?} value
- * @param {?} isInitialized
- * @return {?}
- */
-function (link, callParams, requestOptions, value, isInitialized) {
-    if (isInitialized) {
-        return value;
-    }
-    else {
+    static DONT_SERIALIZE = function () {
         return undefined;
-    }
-});
-if (false) {
-    /** @type {?} */
-    LinkSerializer.DONT_SERIALIZE;
-    /** @type {?} */
-    LinkSerializer.AS_LINK;
-    /** @type {?} */
-    LinkSerializer.AS_VALUE_IF_INITIALIZED;
+    };
+    static AS_LINK = function (link) {
+        return link;
+    };
+    static AS_VALUE_IF_INITIALIZED = function (link, callParams, requestOptions, value, isInitialized) {
+        if (isInitialized) {
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
 class LinkField extends CallableLink {
-    /**
-     * @param {?} link
-     * @param {?} microClient
-     * @param {?=} initialValue
-     * @param {?=} initialized
-     * @param {?=} callParams
-     * @param {?=} requestOptions
-     */
+    value;
+    initialized = false;
+    _getPromise;
+    valueSubj;
+    serializeTo = LinkSerializer.AS_VALUE_IF_INITIALIZED;
     constructor(link, microClient, initialValue = null, initialized = false, callParams = null, requestOptions = null) {
         super(link, microClient, callParams, requestOptions);
-        this.initialized = false;
-        this.serializeTo = LinkSerializer.AS_VALUE_IF_INITIALIZED;
-        this.intervalId = null;
-        this.isRefreshing = false;
         if (initialized) {
             this.set(initialValue);
         }
     }
-    /**
-     * @template T
-     * @param {?} value
-     * @return {?}
-     */
     static from(value) {
         return new LinkField(null, null, value, true);
     }
-    /**
-     * @param {?=} callback
-     * @return {?}
-     */
     get(callback) {
         if (callback) {
             this.getObs().subscribe(callback);
@@ -490,113 +268,70 @@ class LinkField extends CallableLink {
         }
         return this.getPromise();
     }
-    /**
-     * @return {?}
-     */
     getPromise() {
         if (!this._getPromise) {
             this._getPromise = this.getObs().toPromise();
         }
         return this._getPromise;
     }
-    /**
-     * @param {?=} interval
-     * @param {?=} errorHandler
-     * @return {?}
-     */
+    intervalId = null;
+    isRefreshing = false;
     refresh(interval, errorHandler) {
         if (interval) {
             this.stopRefresh();
         }
-        /** @type {?} */
-        let resCb = (/**
-         * @return {?}
-         */
-        () => {
+        let resCb = () => {
             this.isRefreshing = false;
-        });
+        };
         this.isRefreshing = true;
-        this.initWithObs().subscribe(resCb, (/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => {
+        this.initWithObs().subscribe(resCb, (error) => {
             resCb();
             if (errorHandler) {
                 errorHandler(error);
             }
-        }), resCb);
+        }, resCb);
         if (interval) {
-            this.intervalId = setInterval((/**
-             * @return {?}
-             */
-            () => {
+            this.intervalId = setInterval(() => {
                 if (!this.isRefreshing) {
                     this.isRefreshing = true;
-                    this.initWithObs().subscribe(resCb, (/**
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    (error) => {
+                    this.initWithObs().subscribe(resCb, (error) => {
                         resCb();
                         if (errorHandler) {
                             errorHandler(error);
                         }
-                    }), resCb);
+                    }, resCb);
                 }
-            }), interval);
+            }, interval);
         }
     }
-    /**
-     * @return {?}
-     */
     stopRefresh() {
         if (this.intervalId) {
             clearInterval(this.intervalId);
         }
     }
-    /**
-     * @return {?}
-     */
     listenObs() {
         //TODO handle listeners in case of intermidiate uninitialize (new valueSubj)
         if (this.valueSubj) {
             return this.valueSubj;
         }
         else {
-            /** @type {?} */
             let valueSubj = new ReplaySubject(1);
             this.valueSubj = valueSubj;
-            return defer((/**
-             * @return {?}
-             */
-            () => {
-                this.initWithObs(null, null).subscribe((/**
-                 * @param {?} value
-                 * @return {?}
-                 */
-                (value) => {
+            return defer(() => {
+                this.initWithObs(null, null).subscribe((value) => {
                     if (this.valueSubj !== valueSubj) {
                         valueSubj.next(value);
                         valueSubj.complete();
                     }
-                }));
+                });
                 return valueSubj;
-            }));
+            });
         }
     }
-    /**
-     * @return {?}
-     */
     getObs() {
         return this.listenObs().pipe(take(1));
     }
-    /**
-     * @param {?} value
-     * @return {?}
-     */
     set(value) {
-        /** @type {?} */
         const oldValue = this.value;
         this.value = value;
         this.initialized = true;
@@ -607,75 +342,38 @@ class LinkField extends CallableLink {
         this._getPromise = null;
         return oldValue;
     }
-    /**
-     * @return {?}
-     */
     isInitialized() {
         return this.initialized;
     }
-    /**
-     * @return {?}
-     */
     uninitialize() {
         this.value = null;
         this.initialized = false;
         this.valueSubj = null;
         this._getPromise = null;
     }
-    /**
-     * @return {?}
-     */
     copyUninitialized() {
-        /** @type {?} */
         let copy = this.copy();
         copy.uninitialize();
         return copy;
     }
-    /**
-     * @return {?}
-     */
     getInitializedValue() {
         if (!this.isInitialized()) {
             throw new Error('Can\'t get the intialized value for a LinkField that hasn\'t been initialized');
         }
         return this.value;
     }
-    /**
-     * @param {?=} parms
-     * @param {?=} requestOptions
-     * @param {?=} callback
-     * @return {?}
-     */
     initWith(parms = null, requestOptions = null, callback) {
         this.initWithObs(parms, requestOptions).subscribe(callback);
     }
-    /**
-     * @param {?=} params
-     * @param {?=} requestOptions
-     * @return {?}
-     */
     initWithObs(params = null, requestOptions = null) {
-        return this.callWithObs(params, requestOptions).pipe(map((/**
-         * @param {?} value
-         * @return {?}
-         */
-        (value) => {
-            this.set((/** @type {?} */ (value)));
+        return this.callWithObs(params, requestOptions).pipe(map((value) => {
+            this.set(value);
             return value;
-        })));
+        }));
     }
-    /**
-     * @param {?} callParams
-     * @param {?=} requestOptions
-     * @return {?}
-     */
     withCallParams(callParams, requestOptions = this.requestOptions) {
         return new LinkField(this.link, this.microClient, this.value, this.initialized, callParams, requestOptions);
     }
-    /**
-     * @param {?=} withValue
-     * @return {?}
-     */
     copy(withValue) {
         if (withValue === undefined) {
             return new LinkField(this.link, this.microClient, this.value, this.initialized, this.callParams, this.requestOptions);
@@ -684,9 +382,6 @@ class LinkField extends CallableLink {
             return new LinkField(this.link, this.microClient, withValue, true, this.callParams, this.requestOptions);
         }
     }
-    /**
-     * @return {?}
-     */
     toJSON() {
         if (this.serializeTo) {
             return this.serializeTo(this.link, this.callParams, this.requestOptions, this.value, this.isInitialized());
@@ -696,101 +391,33 @@ class LinkField extends CallableLink {
         }
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype.value;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype.initialized;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype._getPromise;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype.valueSubj;
-    /** @type {?} */
-    LinkField.prototype.serializeTo;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype.intervalId;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkField.prototype.isRefreshing;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-// WARNING: interface has both a type and a value, skipping emit
 class MicroObject {
-    constructor() {
-        this.__meta = undefined;
-    }
-    /**
-     * @template T
-     * @param {?} toCopy
-     * @param {?=} client
-     * @return {?}
-     */
+    static META_KEY = '__meta';
+    __meta = undefined;
     static deepCopy(toCopy, client) {
-        return (/** @type {?} */ (cloneDeepWith(toCopy, MicroObject.deepCopyCustomizer)));
+        return _.cloneDeepWith(toCopy, MicroObject.deepCopyCustomizer);
     }
-    /**
-     * @private
-     * @param {?} value
-     * @return {?}
-     */
     static deepCopyCustomizer(value) {
         if (value instanceof MicroClient) {
             return value;
         }
         return undefined;
     }
-    /**
-     * @template T
-     * @param {?} str
-     * @param {?} client
-     * @param {?=} prototype
-     * @return {?}
-     */
     static fromString(str, client, prototype = null) {
-        /** @type {?} */
         const obj = JSON.parse(str);
         return this.fromObject(obj, client, prototype);
     }
-    /**
-     * @template T
-     * @param {?} obj
-     * @param {?} client
-     * @param {?=} prototype
-     * @return {?}
-     */
     static fromObject(obj, client, prototype = null) {
         if (obj === null) {
             return null;
         }
         if (Array.isArray(obj)) {
-            /** @type {?} */
             const objArr = obj;
             for (let i = 0; i < objArr.length; i++) {
-                /** @type {?} */
                 const elem = objArr[i];
                 if (typeof elem === 'object') {
-                    objArr[i] = (/** @type {?} */ (MicroObject.fromObject(elem, client, prototype)));
+                    objArr[i] = MicroObject.fromObject(elem, client, prototype);
                 }
             }
             return objArr;
@@ -798,7 +425,6 @@ class MicroObject {
         else {
             for (const field in obj) {
                 if (field !== MicroObject.META_KEY && obj.hasOwnProperty(field)) {
-                    /** @type {?} */
                     const fieldValue = obj[field];
                     if (fieldValue) {
                         if (fieldValue instanceof Object || Array.isArray(fieldValue)) {
@@ -807,25 +433,15 @@ class MicroObject {
                     }
                 }
             }
-            /** @type {?} */
             const src = prototype == null ? MicroObject.prototype : prototype;
-            /** @type {?} */
             const microObject = Object.assign(Object.create(src), obj);
             MicroObject.attachMetadataObject(microObject, client);
-            return (/** @type {?} */ (microObject));
+            return microObject;
         }
     }
-    /**
-     * @private
-     * @param {?} microObject
-     * @param {?} client
-     * @return {?}
-     */
     static attachMetadataObject(microObject, client) {
-        /** @type {?} */
         const rawMeta = microObject != null ? microObject[MicroObject.META_KEY] : null;
         if (rawMeta != null) {
-            /** @type {?} */
             let clientToUse = client;
             if (rawMeta.permitToken) {
                 if (client.getEntryPoint() != null) {
@@ -840,83 +456,38 @@ class MicroObject {
             return null;
         }
     }
-    /**
-     * @private
-     * @param {?} meta
-     * @param {?} microObject
-     * @param {?} client
-     * @return {?}
-     */
     static attachLinkFields(meta, microObject, client) {
-        meta.forEachLink((/**
-         * @param {?} linkName
-         * @param {?} linkUrl
-         * @return {?}
-         */
-        (linkName, linkUrl) => {
-            /** @type {?} */
+        meta.forEachLink((linkName, linkUrl) => {
             const value = microObject[linkName];
             microObject[linkName] = new LinkField(linkUrl, client, value, value !== undefined);
-        }));
+        });
     }
-    /**
-     * @private
-     * @param {?} meta
-     * @param {?} microObject
-     * @param {?} client
-     * @return {?}
-     */
     static attachCallableLinks(meta, microObject, client) {
-        meta.forEachAction((/**
-         * @param {?} linkName
-         * @param {?} linkUrl
-         * @return {?}
-         */
-        (linkName, linkUrl) => {
+        meta.forEachAction((linkName, linkUrl) => {
             microObject[linkName] = new CallableLink(linkUrl, client);
-        }));
+        });
     }
 }
-MicroObject.META_KEY = '__meta';
-if (false) {
-    /** @type {?} */
-    MicroObject.META_KEY;
-    /** @type {?} */
-    MicroObject.prototype.__meta;
-}
 class MicroObjectMetadata {
-    /**
-     * @param {?} obj
-     * @param {?} client
-     * @return {?}
-     */
+    links;
+    actions;
+    permitToken;
+    nextPage;
+    error;
     static fromObject(obj, client) {
-        /** @type {?} */
         const objMetadata = Object.assign(new MicroObjectMetadata(), obj);
         if (objMetadata.nextPage != null) {
-            objMetadata.nextPage = new LinkField((/** @type {?} */ (objMetadata.nextPage)), client);
+            objMetadata.nextPage = new LinkField(objMetadata.nextPage, client);
             objMetadata.nextPage.serializeTo = LinkSerializer.AS_LINK;
         }
         return objMetadata;
     }
-    /**
-     * @param {?} key
-     * @return {?}
-     */
     getLinkUrl(key) {
         return this.links[key];
     }
-    /**
-     * @param {?} key
-     * @return {?}
-     */
     hasLink(key) {
         return this.links[key] != null;
     }
-    /**
-     * @param {?} op
-     * @return {?}
-     */
     forEachLink(op) {
         for (const link in this.links) {
             if (this.links.hasOwnProperty(link)) {
@@ -924,10 +495,6 @@ class MicroObjectMetadata {
             }
         }
     }
-    /**
-     * @param {?} op
-     * @return {?}
-     */
     forEachAction(op) {
         for (const link in this.actions) {
             if (this.actions.hasOwnProperty(link)) {
@@ -936,93 +503,46 @@ class MicroObjectMetadata {
         }
     }
 }
-if (false) {
-    /** @type {?} */
-    MicroObjectMetadata.prototype.links;
-    /** @type {?} */
-    MicroObjectMetadata.prototype.actions;
-    /** @type {?} */
-    MicroObjectMetadata.prototype.permitToken;
-    /** @type {?} */
-    MicroObjectMetadata.prototype.nextPage;
-    /** @type {?} */
-    MicroObjectMetadata.prototype.error;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroError {
-}
-if (false) {
-    /** @type {?} */
-    MicroError.prototype.timestamp;
-    /** @type {?} */
-    MicroError.prototype.errorMessage;
-    /** @type {?} */
-    MicroError.prototype.atService;
-    /** @type {?} */
-    MicroError.prototype.atEndpoint;
-    /** @type {?} */
-    MicroError.prototype.instanceID;
-    /** @type {?} */
-    MicroError.prototype.httpEquivCode;
-    /** @type {?} */
-    MicroError.prototype.cause;
-    /** @type {?} */
-    MicroError.prototype.errorID;
-    /** @type {?} */
-    MicroError.prototype.errorType;
+    timestamp;
+    errorMessage;
+    atService;
+    atEndpoint;
+    instanceID;
+    httpEquivCode;
+    cause;
+    errorID;
+    errorType;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroClient {
-    /**
-     * @param {?} httpClient
-     */
+    httpClient;
+    authHeader;
+    permitToken;
+    entryPoint;
+    entryPointSubject = new ReplaySubject();
+    urlRewriter;
+    defaultErrorHandler;
+    usePost = true;
+    sendAsPermitTokenHeader = true;
+    sendAsMultipartFormData = false;
     constructor(httpClient) {
         this.httpClient = httpClient;
-        this.entryPointSubject = new ReplaySubject();
-        this.usePost = true;
-        this.sendAsPermitTokenHeader = true;
-        this.sendAsMultipartFormData = false;
-    }
-    /**
-     * @param {?} sendAsPermitTokenHeader
-     * @return {?}
-     */
+    }
     setSendAsPermitTokenHeader(sendAsPermitTokenHeader) {
         this.sendAsPermitTokenHeader = sendAsPermitTokenHeader;
     }
-    /**
-     * @param {?} token
-     * @return {?}
-     */
     setAuthToken(token) {
         this.authHeader = 'Bearer ' + token;
         this.permitToken = token;
     }
-    /**
-     * @param {?} authHeader
-     * @return {?}
-     */
     setAuthHeader(authHeader) {
         this.authHeader = authHeader;
     }
-    /**
-     * @return {?}
-     */
     getEntryPoint() {
         return this.entryPoint;
     }
-    /**
-     * @param {?=} cb
-     * @return {?}
-     */
     waitForEntryPoint(cb) {
         if (cb != null) {
             this.entryPointSubject.subscribe(cb);
@@ -1030,20 +550,11 @@ class MicroClient {
         }
         return this.entryPointSubject.toPromise();
     }
-    /**
-     * @param {?} other
-     * @return {?}
-     */
     copyAuthAndEntrypointOf(other) {
         this.authHeader = other.authHeader;
         this.permitToken = other.permitToken;
         this.entryPoint = other.entryPoint;
     }
-    /**
-     * @template T
-     * @param {?} entryPoint
-     * @return {?}
-     */
     setEntryPoint(entryPoint) {
         if (entryPoint == null) {
             this.authHeader = null;
@@ -1061,24 +572,14 @@ class MicroClient {
             this.entryPointSubject.next(entryPoint);
         }
     }
-    /**
-     * @param {?} handler
-     * @return {?}
-     */
     setDefaultErrorHandler(handler) {
         this.defaultErrorHandler = handler;
     }
-    /**
-     * @param {?} httpErr
-     * @return {?}
-     */
     handleError(httpErr) {
         if (this.defaultErrorHandler) {
-            /** @type {?} */
             const microError = MicroClient.toMicroError(httpErr);
             if (microError) {
-                /** @type {?} */
-                const microResultObj = (/** @type {?} */ (MicroObject.fromObject(httpErr.error, this)));
+                const microResultObj = MicroObject.fromObject(httpErr.error, this);
                 this.defaultErrorHandler(httpErr, microResultObj);
             }
             else {
@@ -1086,19 +587,10 @@ class MicroClient {
             }
         }
     }
-    /**
-     * @template T
-     * @param {?} url
-     * @param {?=} username
-     * @param {?=} password
-     * @param {?=} headers
-     * @return {?}
-     */
     ignite(url, username = null, password = null, headers = {}) {
         if (this.urlRewriter) {
             url = this.urlRewriter(url);
         }
-        /** @type {?} */
         let requestHeaders = new HttpHeaders();
         for (const headerKey in headers) {
             if (headers.hasOwnProperty(headerKey)) {
@@ -1110,26 +602,13 @@ class MicroClient {
         }
         return this.httpClient.get(url, {
             headers: requestHeaders
-        }).pipe(map((/**
-         * @param {?} val
-         * @return {?}
-         */
-        val => {
-            /** @type {?} */
+        }).pipe(map(val => {
             const entryPoint = MicroObject.fromObject(val, this);
             this.setEntryPoint(entryPoint);
-            return (/** @type {?} */ (entryPoint));
-        })), this.catchAndHandleError());
-    }
-    /**
-     * @template T
-     * @param {?} url
-     * @param {?=} params
-     * @param {?=} requestOptions
-     * @return {?}
-     */
+            return entryPoint;
+        }), this.catchAndHandleError());
+    }
     load(url, params, requestOptions) {
-        /** @type {?} */
         let requestHeaders = new HttpHeaders();
         if (this.authHeader) {
             requestHeaders = requestHeaders.set('Authorization', this.authHeader);
@@ -1137,12 +616,9 @@ class MicroClient {
                 requestHeaders = requestHeaders.set('MicroPermitToken', this.permitToken);
             }
         }
-        /** @type {?} */
         let oParams = params;
         if (params != null || this.usePost) {
-            /** @type {?} */
             const existingParamsStr = ParamUtils.getParam(url, 'oParams', true);
-            /** @type {?} */
             let existingParams;
             if (existingParamsStr) {
                 existingParams = JSON.parse(existingParamsStr);
@@ -1152,10 +628,8 @@ class MicroClient {
             }
             oParams = Object.assign(existingParams, params);
         }
-        /** @type {?} */
         let options = requestOptions;
         if (requestOptions != null || this.usePost) {
-            /** @type {?} */
             const prevOptionsStr = ParamUtils.getParam(url, 'options', true);
             if (prevOptionsStr) {
                 options = JSON.parse(prevOptionsStr);
@@ -1165,19 +639,14 @@ class MicroClient {
             }
             options = Object.assign(options, requestOptions);
         }
-        /** @type {?} */
         const queryParams = ParamUtils.getParams(url);
-        /** @type {?} */
         let httpObs = null;
         if (this.usePost) {
-            /** @type {?} */
             let bOParams;
-            /** @type {?} */
             const encBOParams = queryParams['bOParams'];
             if (encBOParams) {
                 bOParams = JSON.parse(ParamUtils.base64UrlDecode(encBOParams));
             }
-            /** @type {?} */
             const body = {
                 params: queryParams['params'],
                 oParams: oParams,
@@ -1213,25 +682,14 @@ class MicroClient {
                 headers: requestHeaders
             });
         }
-        httpObs = httpObs.pipe(map((/**
-         * @param {?} val
-         * @return {?}
-         */
-        val => {
+        httpObs = httpObs.pipe(map(val => {
             return MicroObject.fromObject(val, this);
-        })), this.catchAndHandleError());
+        }), this.catchAndHandleError());
         return httpObs;
     }
-    /**
-     * @private
-     * @param {?} body
-     * @return {?}
-     */
     encodeBody(body) {
         if (this.sendAsMultipartFormData) {
-            /** @type {?} */
             let formData = new FormData();
-            /** @type {?} */
             let paramBlob = new Blob([JSON.stringify(body)], { type: "application/json" });
             formData.append('*', paramBlob);
             return formData;
@@ -1240,48 +698,22 @@ class MicroClient {
             return body;
         }
     }
-    /**
-     * @private
-     * @template T
-     * @return {?}
-     */
     catchAndHandleError() {
-        return (/**
-         * @param {?} source
-         * @return {?}
-         */
-        (source) => {
-            return source.pipe(catchError((/**
-             * @param {?} err
-             * @return {?}
-             */
-            err => {
-                /** @type {?} */
-                let loadError = new MicroClientLoadError(err, (/**
-                 * @param {?} errToHandle
-                 * @return {?}
-                 */
-                (errToHandle) => {
+        return (source) => {
+            return source.pipe(catchError(err => {
+                let loadError = new MicroClientLoadError(err, (errToHandle) => {
                     this.handleError(errToHandle);
-                }));
-                return throwError(loadError).pipe(finalize((/**
-                 * @return {?}
-                 */
-                () => {
+                });
+                return throwError(loadError).pipe(finalize(() => {
                     if (!loadError.shouldPreventDefault()) {
                         loadError.handleDefault();
                     }
-                })));
-            })));
-        });
+                }));
+            }));
+        };
     }
-    /**
-     * @param {?} entryPoint
-     * @return {?}
-     */
     createChildClientForEntryPoint(entryPoint) {
         if (entryPoint.__meta && entryPoint.__meta.permitToken) {
-            /** @type {?} */
             const childClient = Object.create(this, {
                 entryPoint: {
                     configurable: true,
@@ -1306,30 +738,18 @@ class MicroClient {
             throw new Error('The supplied value can\'t be used to construct a child MicroClient because it doesn\'t contain metadata with a permitToken ');
         }
     }
-    /**
-     * @param {?} rewriter
-     * @return {?}
-     */
     setURLRewriter(rewriter) {
         this.urlRewriter = rewriter;
     }
-    /**
-     * @param {?} httpResponse
-     * @return {?}
-     */
     static toMicroError(httpResponse) {
-        /** @type {?} */
         const res = httpResponse.error;
         if (res && res.__meta && res.__meta.error) {
             return Object.assign(new MicroError(), res.__meta.error);
         }
         return null;
     }
-    /**
-     * @return {?}
-     */
+    static staticContentRegExp = new RegExp('[a-zA-Z0-9]://.*(:[0-9]+)?(/.*)*/static(/.*(\\?.*)?(#.*)?)?');
     static guessMicroComponentBaseURL() {
-        /** @type {?} */
         const href = window.location.href;
         // Last URL-Segement is static
         if (MicroClient.staticContentRegExp.test(href)) {
@@ -1345,215 +765,73 @@ class MicroClient {
             }
         }
     }
-    /**
-     * @return {?}
-     */
     static guessMicroComponentAuthorizeURL() {
         return this.guessMicroComponentBaseURL() + '/authorize';
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClient, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClient });
 }
-MicroClient.staticContentRegExp = new RegExp('[a-zA-Z0-9]://.*(:[0-9]+)?(/.*)*/static(/.*(\\?.*)?(#.*)?)?');
-MicroClient.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-MicroClient.ctorParameters = () => [
-    { type: HttpClient }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.staticContentRegExp;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.authHeader;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.permitToken;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.entryPoint;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.entryPointSubject;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.urlRewriter;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.defaultErrorHandler;
-    /** @type {?} */
-    MicroClient.prototype.usePost;
-    /** @type {?} */
-    MicroClient.prototype.sendAsPermitTokenHeader;
-    /** @type {?} */
-    MicroClient.prototype.sendAsMultipartFormData;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClient.prototype.httpClient;
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
 class MicroClientLoadError {
-    /**
-     * @param {?} error
-     * @param {?} defaultHandler
-     */
+    error;
+    defaultHandler;
+    handled = false;
+    doPreventDefault = false;
     constructor(error, defaultHandler) {
         this.error = error;
         this.defaultHandler = defaultHandler;
-        this.handled = false;
-        this.doPreventDefault = false;
     }
-    /**
-     * @return {?}
-     */
     handleDefault() {
         if (this.defaultHandler) {
             this.defaultHandler(this.error);
             this.handled = true;
         }
     }
-    /**
-     * @param {?} handler
-     * @return {?}
-     */
     handleError(handler) {
         handler(this.error);
         this.handled = true;
     }
-    /**
-     * @return {?}
-     */
     isHandled() {
         return this.handled;
     }
-    /**
-     * @return {?}
-     */
     shouldPreventDefault() {
         return this.doPreventDefault;
     }
-    /**
-     * @return {?}
-     */
     preventDefault() {
         this.doPreventDefault = true;
     }
-    /**
-     * @return {?}
-     */
     hasDefaultHandler() {
         return this.defaultHandler != null;
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClientLoadError.prototype.handled;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClientLoadError.prototype.doPreventDefault;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClientLoadError.prototype.error;
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroClientLoadError.prototype.defaultHandler;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroClientLoadingIndicatorComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientLoadingIndicatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.5", type: MicroClientLoadingIndicatorComponent, isStandalone: false, selector: "mc-loadingindicator", ngImport: i0, template: `
+        <div id="container">
+            <div id="bar"></div>
+        </div>
+    `, isInline: true, styles: ["#container{display:block;overflow:hidden;width:100%;height:5px;-webkit-transform:translate(0,0) scale(1,1);transform:translate(0) scale(1);background-color:#aad1f9}#container #bar{transition:all .2s linear;-webkit-animation:query .8s infinite cubic-bezier(.39,.575,.565,1);animation:query .8s infinite cubic-bezier(.39,.575,.565,1);transition:-webkit-transform .2s linear;transition:transform .2s linear;background-color:#106cc8;width:100%;height:5px}@keyframes query{0%{opacity:1;transform:translate(35%) scaleX(.3)}to{opacity:0;transform:translate(-50%) scaleX(0)}}\n"] });
 }
-MicroClientLoadingIndicatorComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'mc-loadingindicator',
-                template: `
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientLoadingIndicatorComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: 'mc-loadingindicator', template: `
         <div id="container">
             <div id="bar"></div>
         </div>
-    `,
-                styles: [`
-        #container {
-            display: block;
-            overflow: hidden;
-            width: 100%;
-            height: 5px;
-            -webkit-transform: translate(0, 0) scale(1, 1);
-            transform: translate(0, 0) scale(1, 1);
-            background-color: #aad1f9;
-        }
-        #container #bar {
-            transition: all .2s linear;
-            -webkit-animation: query 0.8s infinite cubic-bezier(0.39, 0.575, 0.565, 1);
-            animation: query 0.8s infinite cubic-bezier(0.39, 0.575, 0.565, 1);
-            transition: -webkit-transform .2s linear;
-            transition: transform .2s linear;
-            background-color: #106cc8;
-            width: 100%;
-            height: 5px;
-        }
-        @keyframes query {
-            0% {
-                opacity: 1;
-                transform: translateX(35%) scale(0.3, 1);
-            }
-            100% {
-                opacity: 0;
-                transform: translateX(-50%) scale(0, 1);
-            }
-        }
-    `]
-            }] }
-];
+    `, styles: ["#container{display:block;overflow:hidden;width:100%;height:5px;-webkit-transform:translate(0,0) scale(1,1);transform:translate(0) scale(1);background-color:#aad1f9}#container #bar{transition:all .2s linear;-webkit-animation:query .8s infinite cubic-bezier(.39,.575,.565,1);animation:query .8s infinite cubic-bezier(.39,.575,.565,1);transition:-webkit-transform .2s linear;transition:transform .2s linear;background-color:#106cc8;width:100%;height:5px}@keyframes query{0%{opacity:1;transform:translate(35%) scaleX(.3)}to{opacity:0;transform:translate(-50%) scaleX(0)}}\n"] }]
+        }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class LinkFieldPipe {
-    /**
-     * @param {?} changeDetectorRef
-     */
+    asyncPipe;
     constructor(changeDetectorRef) {
         this.asyncPipe = new AsyncPipe(changeDetectorRef);
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this.asyncPipe.ngOnDestroy();
     }
-    /**
-     * @template T
-     * @param {?} linkField
-     * @return {?}
-     */
     transform(linkField) {
         if (linkField == null) {
             return null;
@@ -1566,142 +844,85 @@ class LinkFieldPipe {
             throw new Error('Can\'t use the linkField pipe with a value which isn\'t an instance of LinkField');
         }
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: LinkFieldPipe, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: LinkFieldPipe, isStandalone: false, name: "linkField", pure: false });
 }
-LinkFieldPipe.decorators = [
-    { type: Pipe, args: [{ name: 'linkField', pure: false },] }
-];
-/** @nocollapse */
-LinkFieldPipe.ctorParameters = () => [
-    { type: ChangeDetectorRef }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPipe.prototype.asyncPipe;
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: LinkFieldPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'linkField',
+                    pure: false,
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroClientErrorIndicatorComponent {
-    /**
-     * @return {?}
-     */
+    error;
     onClick() {
         this.error.handleDefault();
     }
-}
-MicroClientErrorIndicatorComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'mc-errorindicator',
-                template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientErrorIndicatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.5", type: MicroClientErrorIndicatorComponent, isStandalone: false, selector: "mc-errorindicator", inputs: { error: "error" }, ngImport: i0, template: `
         <div class="blinking-error" [class.clickable]="error.hasDefaultHandler()" (click)="onClick()"></div>
-    `,
-                styles: [`
-        .blinking-error {
-            background-image: linear-gradient(to right, tomato 0%, darkred 50%, tomato 100%);
-            animation: blinkingText 0.5s 1;
-            height: 5px;
-        }
-
-        .blinking-error.clickable {
-            cursor: pointer;
-        }
-
-        @keyframes blinkingText {
-            0% {
-                opacity: 0;
-            }
-            50% {
-                opacity: 1;
-            }
-            100% {
-                opacity: 0;
-            }
-        }
-    `]
-            }] }
-];
-MicroClientErrorIndicatorComponent.propDecorators = {
-    error: [{ type: Input }]
-};
-if (false) {
-    /** @type {?} */
-    MicroClientErrorIndicatorComponent.prototype.error;
+    `, isInline: true, styles: [".blinking-error{background-image:linear-gradient(to right,tomato,#8b0000,tomato);animation:blinkingText .5s 1;height:5px}.blinking-error.clickable{cursor:pointer}@keyframes blinkingText{0%{opacity:0}50%{opacity:1}to{opacity:0}}\n"] });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientErrorIndicatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mc-errorindicator', template: `
+        <div class="blinking-error" [class.clickable]="error.hasDefaultHandler()" (click)="onClick()"></div>
+    `, standalone: false, styles: [".blinking-error{background-image:linear-gradient(to right,tomato,#8b0000,tomato);animation:blinkingText .5s 1;height:5px}.blinking-error.clickable{cursor:pointer}@keyframes blinkingText{0%{opacity:0}50%{opacity:1}to{opacity:0}}\n"] }]
+        }], propDecorators: { error: [{
+                type: Input
+            }] } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
 class LinkFieldDirective {
-    /**
-     * @param {?} _viewContainer
-     * @param {?} _template
-     * @param {?} componentResolver
-     * @param {?} changeDetectorRef
-     */
+    _viewContainer;
+    _template;
+    componentResolver;
+    changeDetectorRef;
+    _from;
+    _loadingTemplate;
+    _errorTemplate;
+    _defaultLoadingComponent;
+    _defaultErrorComponent;
+    isDirty = true;
+    isLoading = false;
+    loadedResult = null;
+    hasResult = false;
+    lastObs;
+    subscription = null;
+    currentContext;
     constructor(_viewContainer, _template, componentResolver, changeDetectorRef) {
         this._viewContainer = _viewContainer;
         this._template = _template;
         this.componentResolver = componentResolver;
         this.changeDetectorRef = changeDetectorRef;
-        this.isDirty = true;
-        this.isLoading = false;
-        this.loadedResult = null;
-        this.hasResult = false;
-        this.subscription = null;
-        this.linkFieldDefaultErrorHandling = false;
-        this.linkFieldParams = null;
         this._defaultLoadingComponent = componentResolver.resolveComponentFactory(MicroClientLoadingIndicatorComponent);
         this._defaultErrorComponent = componentResolver.resolveComponentFactory(MicroClientErrorIndicatorComponent);
     }
-    /**
-     * @param {?} from
-     * @return {?}
-     */
     set linkFieldFrom(from) {
         this._from = from;
     }
-    /**
-     * @param {?} loadingTemplate
-     * @return {?}
-     */
     set linkFieldLoadingTemplate(loadingTemplate) {
         if (loadingTemplate) {
             this._loadingTemplate = loadingTemplate;
         }
         this.updateIfDirty(true);
     }
-    /**
-     * @param {?} errorTemplate
-     * @return {?}
-     */
     set linkFieldErrorTemplate(errorTemplate) {
         if (errorTemplate) {
             this._errorTemplate = errorTemplate;
         }
         this.updateIfDirty(true);
     }
-    /**
-     * @param {?} value
-     * @return {?}
-     */
     set linkFieldTemplate(value) {
         if (value) {
             this._template = value;
         }
     }
-    /**
-     * @private
-     * @return {?}
-     */
+    linkFieldDefaultErrorHandling = false;
+    linkFieldValueChange;
+    linkFieldParams = null;
     load() {
         if (this._from) {
             if (this._from instanceof LinkField) {
@@ -1710,30 +931,19 @@ class LinkFieldDirective {
                 if (this.subscription) {
                     this.subscription.unsubscribe();
                 }
-                this.subscription = this.lastObs.pipe(finalize((/**
-                 * @return {?}
-                 */
-                () => {
+                this.subscription = this.lastObs.pipe(finalize(() => {
                     this.setLoading(false);
-                }))).subscribe((/**
-                 * @param {?} loadedResult
-                 * @return {?}
-                 */
-                (loadedResult) => {
+                })).subscribe((loadedResult) => {
                     this.setLoadedResult(loadedResult);
                     if (this.linkFieldValueChange) {
                         this.linkFieldValueChange(loadedResult);
                     }
-                }), (/**
-                 * @param {?} loadError
-                 * @return {?}
-                 */
-                (loadError) => {
+                }, (loadError) => {
                     if (!this.linkFieldDefaultErrorHandling) {
                         loadError.preventDefault();
                     }
                     this.setError(loadError);
-                }));
+                });
             }
             else {
                 this.setLoadedResult(this._from);
@@ -1742,26 +952,16 @@ class LinkFieldDirective {
             }
         }
     }
-    /**
-     * @return {?}
-     */
     ngDoCheck() {
         this.updateIfDirty();
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this.clear();
     }
-    /**
-     * @param {?} changes
-     * @return {?}
-     */
     ngOnChanges(changes) {
         if (changes.linkFieldFrom) {
             if (!(this._from instanceof LinkField)) {
-                this._from = LinkField.from((/** @type {?} */ (this._from)));
+                this._from = LinkField.from(this._from);
             }
             if (changes.linkFieldFrom.previousValue !== changes.linkFieldFrom.currentValue) {
                 this.clear();
@@ -1769,16 +969,10 @@ class LinkFieldDirective {
             }
         }
         if (changes.linkFieldParams && this.linkFieldParams) {
-            /** @type {?} */
-            let link = (/** @type {?} */ (this._from));
+            let link = this._from;
             this._from = link.withCallParams(this.linkFieldParams);
         }
     }
-    /**
-     * @private
-     * @param {?} error
-     * @return {?}
-     */
     setError(error) {
         this._viewContainer.remove();
         if (this._errorTemplate) {
@@ -1787,16 +981,10 @@ class LinkFieldDirective {
             });
         }
         else {
-            /** @type {?} */
             let errorComponentInstance = this._viewContainer.createComponent(this._defaultErrorComponent);
             errorComponentInstance.instance['error'] = error;
         }
     }
-    /**
-     * @private
-     * @param {?} loading
-     * @return {?}
-     */
     setLoading(loading) {
         this.isLoading = loading;
         if (this.isLoading) {
@@ -1810,11 +998,6 @@ class LinkFieldDirective {
             }
         }
     }
-    /**
-     * @private
-     * @param {?} result
-     * @return {?}
-     */
     setLoadedResult(result) {
         this.hasResult = true;
         this.loadedResult = result;
@@ -1837,11 +1020,6 @@ class LinkFieldDirective {
             }
         }
     }
-    /**
-     * @private
-     * @param {?=} ignoreDirty
-     * @return {?}
-     */
     updateIfDirty(ignoreDirty = false) {
         if ((this.isDirty || ignoreDirty) && this._loadingTemplate && this._from && this._template && this._viewContainer) {
             if (this.hasResult) {
@@ -1850,10 +1028,6 @@ class LinkFieldDirective {
             this.isDirty = false;
         }
     }
-    /**
-     * @private
-     * @return {?}
-     */
     clear() {
         this.hasResult = false;
         this.loadedResult = null;
@@ -1865,212 +1039,92 @@ class LinkFieldDirective {
         this.lastObs = null;
         this.currentContext = null;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: LinkFieldDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.5", type: LinkFieldDirective, isStandalone: false, selector: "[linkField][linkFieldFrom]", inputs: { linkFieldFrom: "linkFieldFrom", linkFieldLoadingTemplate: "linkFieldLoadingTemplate", linkFieldErrorTemplate: "linkFieldErrorTemplate", linkFieldTemplate: "linkFieldTemplate", linkFieldDefaultErrorHandling: "linkFieldDefaultErrorHandling", linkFieldValueChange: "linkFieldValueChange", linkFieldParams: "linkFieldParams" }, usesOnChanges: true, ngImport: i0 });
 }
-LinkFieldDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[linkField][linkFieldFrom]'
-            },] }
-];
-/** @nocollapse */
-LinkFieldDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: ComponentFactoryResolver },
-    { type: ChangeDetectorRef }
-];
-LinkFieldDirective.propDecorators = {
-    linkFieldFrom: [{ type: Input }],
-    linkFieldLoadingTemplate: [{ type: Input }],
-    linkFieldErrorTemplate: [{ type: Input }],
-    linkFieldTemplate: [{ type: Input }],
-    linkFieldDefaultErrorHandling: [{ type: Input }],
-    linkFieldValueChange: [{ type: Input }],
-    linkFieldParams: [{ type: Input }]
-};
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._from;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._loadingTemplate;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._errorTemplate;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._defaultLoadingComponent;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._defaultErrorComponent;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.isDirty;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.isLoading;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.loadedResult;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.hasResult;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.lastObs;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.subscription;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.currentContext;
-    /** @type {?} */
-    LinkFieldDirective.prototype.linkFieldDefaultErrorHandling;
-    /** @type {?} */
-    LinkFieldDirective.prototype.linkFieldValueChange;
-    /** @type {?} */
-    LinkFieldDirective.prototype.linkFieldParams;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._viewContainer;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype._template;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.componentResolver;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldDirective.prototype.changeDetectorRef;
-}
-/**
- * @template T
- */
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: LinkFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[linkField][linkFieldFrom]',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ChangeDetectorRef }], propDecorators: { linkFieldFrom: [{
+                type: Input
+            }], linkFieldLoadingTemplate: [{
+                type: Input
+            }], linkFieldErrorTemplate: [{
+                type: Input
+            }], linkFieldTemplate: [{
+                type: Input
+            }], linkFieldDefaultErrorHandling: [{
+                type: Input
+            }], linkFieldValueChange: [{
+                type: Input
+            }], linkFieldParams: [{
+                type: Input
+            }] } });
 class LinkFieldContext {
-    /**
-     * @param {?} $implicit
-     */
+    $implicit;
     constructor($implicit) {
         this.$implicit = $implicit;
     }
 }
-if (false) {
-    /** @type {?} */
-    LinkFieldContext.prototype.$implicit;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class CallLinkDirective {
-    constructor() {
-        this.callStatusChange = new EventEmitter();
-        this.callSucess = new EventEmitter();
-        this.callFinish = new EventEmitter();
-        this.callError = new EventEmitter();
-        this.callStart = new EventEmitter();
-    }
-    /**
-     * @return {?}
-     */
+    callLink;
+    callStatusChange = new EventEmitter();
+    callSucess = new EventEmitter();
+    callFinish = new EventEmitter();
+    callError = new EventEmitter();
+    callStart = new EventEmitter();
+    callOptions;
+    callParameters;
     onClick() {
-        this.callLink.callWithObs(this.callParameters, this.callOptions).subscribe((/**
-         * @param {?} response
-         * @return {?}
-         */
-        (response) => {
+        this.callLink.callWithObs(this.callParameters, this.callOptions).subscribe((response) => {
             this.callSucess.emit(response);
             this.callStatusChange.emit(new CallStatus(this.callLink, CallState.SUCCESS, response, null));
-        }), (/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => {
+        }, (error) => {
             this.callError.emit(error);
             this.callStatusChange.emit(new CallStatus(this.callLink, CallState.ERROR, null, error));
-        }), (/**
-         * @return {?}
-         */
-        () => {
+        }, () => {
             this.callFinish.emit();
-        }));
+        });
         this.callStatusChange.emit(new CallStatus(this.callLink, CallState.CALLING, null, null));
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CallLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.5", type: CallLinkDirective, isStandalone: false, selector: "[callLink]", inputs: { callLink: "callLink", callOptions: "callOptions", callParameters: "callParameters" }, outputs: { callStatusChange: "callStatusChange", callSucess: "callSucess", callFinish: "callFinish", callError: "callError", callStart: "callStart" }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 });
 }
-CallLinkDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[callLink]'
-            },] }
-];
-CallLinkDirective.propDecorators = {
-    callLink: [{ type: Input }],
-    callStatusChange: [{ type: Output }],
-    callSucess: [{ type: Output }],
-    callFinish: [{ type: Output }],
-    callError: [{ type: Output }],
-    callStart: [{ type: Output }],
-    callOptions: [{ type: Input }],
-    callParameters: [{ type: Input }],
-    onClick: [{ type: HostListener, args: ['click',] }]
-};
-if (false) {
-    /** @type {?} */
-    CallLinkDirective.prototype.callLink;
-    /** @type {?} */
-    CallLinkDirective.prototype.callStatusChange;
-    /** @type {?} */
-    CallLinkDirective.prototype.callSucess;
-    /** @type {?} */
-    CallLinkDirective.prototype.callFinish;
-    /** @type {?} */
-    CallLinkDirective.prototype.callError;
-    /** @type {?} */
-    CallLinkDirective.prototype.callStart;
-    /** @type {?} */
-    CallLinkDirective.prototype.callOptions;
-    /** @type {?} */
-    CallLinkDirective.prototype.callParameters;
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CallLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[callLink]',
+                    standalone: false
+                }]
+        }], propDecorators: { callLink: [{
+                type: Input
+            }], callStatusChange: [{
+                type: Output
+            }], callSucess: [{
+                type: Output
+            }], callFinish: [{
+                type: Output
+            }], callError: [{
+                type: Output
+            }], callStart: [{
+                type: Output
+            }], callOptions: [{
+                type: Input
+            }], callParameters: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
 class CallStatus {
-    /**
-     * @param {?} link
-     * @param {?} state
-     * @param {?} response
-     * @param {?} error
-     */
+    link;
+    state;
+    response;
+    error;
     constructor(link, state, response, error) {
         this.link = link;
         this.state = state;
@@ -2078,52 +1132,26 @@ class CallStatus {
         this.error = error;
     }
 }
-if (false) {
-    /** @type {?} */
-    CallStatus.prototype.link;
-    /** @type {?} */
-    CallStatus.prototype.state;
-    /** @type {?} */
-    CallStatus.prototype.response;
-    /** @type {?} */
-    CallStatus.prototype.error;
-}
-/** @enum {number} */
-const CallState = {
-    CALLING: 0,
-    SUCCESS: 1,
-    ERROR: 2,
-};
-CallState[CallState.CALLING] = 'CALLING';
-CallState[CallState.SUCCESS] = 'SUCCESS';
-CallState[CallState.ERROR] = 'ERROR';
+var CallState;
+(function (CallState) {
+    CallState[CallState["CALLING"] = 0] = "CALLING";
+    CallState[CallState["SUCCESS"] = 1] = "SUCCESS";
+    CallState[CallState["ERROR"] = 2] = "ERROR";
+})(CallState || (CallState = {}));
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroLinkValidateDirective {
-    constructor() {
-        this.UNSET = "";
-        this.microLinkValidateField = null;
-        this.microLinkValidateValue = this.UNSET;
-        this.microLinkValidateDebounce = 500;
-    }
-    /**
-     * @param {?} control
-     * @return {?}
-     */
+    UNSET = "";
+    microLinkValidate;
+    microLinkValidateField = null;
+    microLinkValidateValue = this.UNSET;
+    microLinkValidateDebounce = 500;
+    result;
     validate(control) {
-        return timer(this.microLinkValidateDebounce).pipe(switchMap((/**
-         * @return {?}
-         */
-        () => {
-            /** @type {?} */
+        return timer(this.microLinkValidateDebounce).pipe(switchMap(() => {
             let validateValue = this.microLinkValidateValue;
             if (validateValue === this.UNSET) {
                 validateValue = control.value;
             }
-            /** @type {?} */
             let obj = {};
             if (this.microLinkValidateField) {
                 obj[this.microLinkValidateField] = validateValue;
@@ -2131,12 +1159,7 @@ class MicroLinkValidateDirective {
             else {
                 obj = validateValue;
             }
-            return this.microLinkValidate.callWithObs(obj, null).pipe(map((/**
-             * @param {?} validationRes
-             * @return {?}
-             */
-            validationRes => {
-                /** @type {?} */
+            return this.microLinkValidate.callWithObs(obj, null).pipe(map(validationRes => {
                 let hasErrors = false;
                 if (this.microLinkValidateField) {
                     if (validationRes[this.microLinkValidateField] != null) {
@@ -2160,27 +1183,17 @@ class MicroLinkValidateDirective {
                     this.result = null;
                     return null;
                 }
-            })));
-        })));
+            }));
+        }));
     }
-    /**
-     * @param {?} control
-     * @return {?}
-     */
     getControlName(control) {
-        /** @type {?} */
         let controlName = null;
-        /** @type {?} */
         let parent = control.parent;
         // only such parent, which is FormGroup, has a dictionary
         // with control-names as a key and a form-control as a value
         if (parent instanceof FormGroup) {
             // now we will iterate those keys (i.e. names of controls)
-            Object.keys(parent.controls).forEach((/**
-             * @param {?} name
-             * @return {?}
-             */
-            (name) => {
+            Object.keys(parent.controls).forEach((name) => {
                 // and compare the passed control and
                 // a child control of a parent - with provided name (we iterate them all)
                 if (control === parent.controls[name]) {
@@ -2188,60 +1201,45 @@ class MicroLinkValidateDirective {
                     //  and this child - are the same references
                     controlName = name;
                 }
-            }));
+            });
         }
         // we either found a name or simply return null
         return controlName;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroLinkValidateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.5", type: MicroLinkValidateDirective, isStandalone: false, selector: "[microLinkValidate]", inputs: { microLinkValidate: "microLinkValidate", microLinkValidateField: "microLinkValidateField", microLinkValidateValue: "microLinkValidateValue", microLinkValidateDebounce: "microLinkValidateDebounce" }, providers: [
+            {
+                provide: NG_ASYNC_VALIDATORS,
+                useExisting: forwardRef(() => MicroLinkValidateDirective),
+                multi: true
+            }
+        ], exportAs: ["microValidator"], ngImport: i0 });
 }
-MicroLinkValidateDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[microLinkValidate]',
-                providers: [
-                    {
-                        provide: NG_ASYNC_VALIDATORS,
-                        useExisting: forwardRef((/**
-                         * @return {?}
-                         */
-                        () => MicroLinkValidateDirective)),
-                        multi: true
-                    }
-                ],
-                exportAs: 'microValidator'
-            },] }
-];
-MicroLinkValidateDirective.propDecorators = {
-    microLinkValidate: [{ type: Input }],
-    microLinkValidateField: [{ type: Input }],
-    microLinkValidateValue: [{ type: Input }],
-    microLinkValidateDebounce: [{ type: Input }]
-};
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    MicroLinkValidateDirective.prototype.UNSET;
-    /** @type {?} */
-    MicroLinkValidateDirective.prototype.microLinkValidate;
-    /** @type {?} */
-    MicroLinkValidateDirective.prototype.microLinkValidateField;
-    /** @type {?} */
-    MicroLinkValidateDirective.prototype.microLinkValidateValue;
-    /** @type {?} */
-    MicroLinkValidateDirective.prototype.microLinkValidateDebounce;
-    /** @type {?} */
-    MicroLinkValidateDirective.prototype.result;
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroLinkValidateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[microLinkValidate]',
+                    providers: [
+                        {
+                            provide: NG_ASYNC_VALIDATORS,
+                            useExisting: forwardRef(() => MicroLinkValidateDirective),
+                            multi: true
+                        }
+                    ],
+                    exportAs: 'microValidator',
+                    standalone: false
+                }]
+        }], propDecorators: { microLinkValidate: [{
+                type: Input
+            }], microLinkValidateField: [{
+                type: Input
+            }], microLinkValidateValue: [{
+                type: Input
+            }], microLinkValidateDebounce: [{
+                type: Input
+            }] } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class MicroClientModule {
-    /**
-     * @return {?}
-     */
     static forClientRoot() {
         return {
             ngModule: MicroClientModule,
@@ -2250,85 +1248,74 @@ class MicroClientModule {
             ]
         };
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MicroClientModule, declarations: [LinkFieldPipe,
+            LinkFieldDirective,
+            CallLinkDirective,
+            MicroClientLoadingIndicatorComponent,
+            MicroClientErrorIndicatorComponent,
+            MicroLinkValidateDirective], exports: [LinkFieldPipe,
+            LinkFieldDirective,
+            CallLinkDirective,
+            MicroClientErrorIndicatorComponent,
+            MicroClientLoadingIndicatorComponent,
+            MicroLinkValidateDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientModule, providers: [
+            provideHttpClient()
+        ] });
 }
-MicroClientModule.decorators = [
-    { type: NgModule, args: [{
-                entryComponents: [
-                    MicroClientLoadingIndicatorComponent,
-                    MicroClientErrorIndicatorComponent
-                ],
-                imports: [
-                    HttpClientModule
-                ],
-                declarations: [
-                    LinkFieldPipe,
-                    LinkFieldDirective,
-                    CallLinkDirective,
-                    MicroClientLoadingIndicatorComponent,
-                    MicroClientErrorIndicatorComponent,
-                    MicroLinkValidateDirective
-                ],
-                exports: [
-                    LinkFieldPipe,
-                    LinkFieldDirective,
-                    CallLinkDirective,
-                    MicroClientErrorIndicatorComponent,
-                    MicroClientLoadingIndicatorComponent,
-                    MicroLinkValidateDirective
-                ]
-            },] }
-];
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MicroClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [
+                        LinkFieldPipe,
+                        LinkFieldDirective,
+                        CallLinkDirective,
+                        MicroClientLoadingIndicatorComponent,
+                        MicroClientErrorIndicatorComponent,
+                        MicroLinkValidateDirective
+                    ],
+                    exports: [
+                        LinkFieldPipe,
+                        LinkFieldDirective,
+                        CallLinkDirective,
+                        MicroClientErrorIndicatorComponent,
+                        MicroClientLoadingIndicatorComponent,
+                        MicroLinkValidateDirective
+                    ],
+                    providers: [
+                        provideHttpClient()
+                    ]
+                }]
+        }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class LinkFieldPagingSupport {
-    /**
-     * @param {?} pageLink
-     * @param {?} changeDetectorRef
-     * @param {?=} pageLimit
-     */
+    pageLink;
+    changeDetectorRef;
+    pageLimit;
     constructor(pageLink, changeDetectorRef, pageLimit = 200) {
         this.pageLink = pageLink;
         this.changeDetectorRef = changeDetectorRef;
         this.pageLimit = pageLimit;
-        this.sorts = null;
-        this.isLoading = false;
-        this.loadedCompletely = false;
-        this.hasLoaded = false;
-        this._rows = null;
-        this.loadingSubscription = null;
-        this.loadingCallback = (/**
-         * @return {?}
-         */
-        () => {
-            this.setLoading(false);
-        });
     }
-    /**
-     * @return {?}
-     */
+    sorts = null;
+    isLoading = false;
+    loadedCompletely = false;
+    hasLoaded = false;
+    _rows = null;
+    loadingSubscription = null;
+    rowsChangeCallback;
+    isLoadingCallback;
     get rows() {
         if (!this.hasLoaded) {
             this.loadNextPage();
         }
         return this._rows;
     }
-    /**
-     * @param {?} pageLink
-     * @param {?} changeDetectorRef
-     * @param {?=} pageLimit
-     * @return {?}
-     */
     static from(pageLink, changeDetectorRef, pageLimit = 200) {
         return new LinkFieldPagingSupport(pageLink, changeDetectorRef, pageLimit);
     }
-    /**
-     * @param {?} sorts
-     * @param {?=} externalSorting
-     * @return {?}
-     */
     applySort(sorts, externalSorting = true) {
         this.hasLoaded = false;
         this.sorts = null;
@@ -2346,11 +1333,9 @@ class LinkFieldPagingSupport {
             }
         }
     }
-    /**
-     * @param {?=} pageSize
-     * @param {?=} resultCallback
-     * @return {?}
-     */
+    loadingCallback = () => {
+        this.setLoading(false);
+    };
     loadNextPage(pageSize = this.pageLimit, resultCallback = null) {
         if (this.pageLink && !this.isLoading) {
             if (this.loadingSubscription) {
@@ -2361,7 +1346,6 @@ class LinkFieldPagingSupport {
             this.loadedCompletely = false;
             if (this._rows == null) {
                 this.setLoading(true);
-                /** @type {?} */
                 const reqOptions = {};
                 if (this.sorts != null) {
                     reqOptions.sorting = this.sorts;
@@ -2369,37 +1353,26 @@ class LinkFieldPagingSupport {
                 if (pageSize != null) {
                     reqOptions.pageSize = pageSize;
                 }
-                this.loadingSubscription = this.pageLink.initWithObs(null, reqOptions).subscribe((/**
-                 * @param {?} firstPage
-                 * @return {?}
-                 */
-                (firstPage) => {
+                this.loadingSubscription = this.pageLink.initWithObs(null, reqOptions).subscribe((firstPage) => {
                     this.setRows(firstPage, resultCallback);
-                }), this.loadingCallback, this.loadingCallback);
+                }, this.loadingCallback, this.loadingCallback);
             }
             else {
-                /** @type {?} */
                 const lastRow = this.lastRow();
                 if (lastRow) {
                     if (lastRow.__meta.nextPage) {
-                        /** @type {?} */
                         let reqOptions = null;
                         if (pageSize != null) {
                             reqOptions = {
                                 pageSize: pageSize
                             };
                         }
-                        /** @type {?} */
                         const nextPageObs = lastRow.__meta.nextPage.initWithObs(null, reqOptions);
                         if (nextPageObs) {
                             this.setLoading(true);
-                            this.loadingSubscription = nextPageObs.subscribe((/**
-                             * @param {?} nextPage
-                             * @return {?}
-                             */
-                            (nextPage) => {
+                            this.loadingSubscription = nextPageObs.subscribe((nextPage) => {
                                 this.setRows(nextPage, resultCallback);
-                            }), this.loadingCallback, this.loadingCallback);
+                            }, this.loadingCallback, this.loadingCallback);
                         }
                     }
                 }
@@ -2409,25 +1382,12 @@ class LinkFieldPagingSupport {
             this.clearRows();
         }
     }
-    /**
-     * @return {?}
-     */
     loadEverything() {
         this.loadNextPage(null);
     }
-    /**
-     * @private
-     * @return {?}
-     */
     lastRow() {
         return this._rows[this._rows.length - 1];
     }
-    /**
-     * @private
-     * @param {?} additionalPage
-     * @param {?} loadCallback
-     * @return {?}
-     */
     setRows(additionalPage, loadCallback) {
         if (this._rows) {
             this._rows = [...this.rows, ...additionalPage];
@@ -2440,22 +1400,13 @@ class LinkFieldPagingSupport {
         }
         this.reflectChanges();
     }
-    /**
-     * @private
-     * @return {?}
-     */
     clearRows() {
         if (this._rows != null) {
             this._rows = null;
             this.reflectChanges();
         }
     }
-    /**
-     * @private
-     * @return {?}
-     */
     reflectChanges() {
-        /** @type {?} */
         const lastRow = this.lastRow();
         if (lastRow && lastRow.__meta) {
             this.loadedCompletely = lastRow.__meta.nextPage == null;
@@ -2468,11 +1419,6 @@ class LinkFieldPagingSupport {
         }
         this.changeDetectorRef.detectChanges();
     }
-    /**
-     * @private
-     * @param {?} isLoading
-     * @return {?}
-     */
     setLoading(isLoading) {
         this.isLoading = isLoading;
         if (this.isLoadingCallback) {
@@ -2480,41 +1426,22 @@ class LinkFieldPagingSupport {
         }
         this.changeDetectorRef.detectChanges();
     }
-    /**
-     * @return {?}
-     */
     dispose() {
         this.rowsChangeCallback = null;
         this.isLoadingCallback = null;
     }
-    /**
-     * @param {?} pageLink
-     * @return {?}
-     */
     setPageLink(pageLink) {
         this.clearState();
         this.pageLink = pageLink;
         this.loadNextPage();
     }
-    /**
-     * @return {?}
-     */
     hasLoadedCompletely() {
         return this.loadedCompletely;
     }
-    /**
-     * @param {?} rowsChangeCallback
-     * @param {?=} isLoadingCallback
-     * @return {?}
-     */
     init(rowsChangeCallback, isLoadingCallback = null) {
         this.rowsChangeCallback = rowsChangeCallback;
         this.isLoadingCallback = isLoadingCallback;
     }
-    /**
-     * @private
-     * @return {?}
-     */
     clearState() {
         this.isLoading = false;
         this.loadedCompletely = false;
@@ -2526,61 +1453,9 @@ class LinkFieldPagingSupport {
         }
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.sorts;
-    /** @type {?} */
-    LinkFieldPagingSupport.prototype.isLoading;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.loadedCompletely;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.hasLoaded;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype._rows;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.loadingSubscription;
-    /** @type {?} */
-    LinkFieldPagingSupport.prototype.rowsChangeCallback;
-    /** @type {?} */
-    LinkFieldPagingSupport.prototype.isLoadingCallback;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.loadingCallback;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.pageLink;
-    /**
-     * @type {?}
-     * @private
-     */
-    LinkFieldPagingSupport.prototype.changeDetectorRef;
-    /** @type {?} */
-    LinkFieldPagingSupport.prototype.pageLimit;
-}
 class SortInfo {
-    /**
-     * @param {?} field
-     * @param {?} dir
-     */
+    field;
+    dir;
     constructor(field, dir) {
         this.field = field;
         this.dir = dir;
@@ -2590,61 +1465,27 @@ class SortInfo {
         }
     }
 }
-if (false) {
-    /** @type {?} */
-    SortInfo.prototype.field;
-    /** @type {?} */
-    SortInfo.prototype.dir;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
 class MockLinkField extends LinkField {
-    /**
-     * @param {?} valueToLoad
-     * @param {?} delay
-     */
+    valueToLoad;
+    delay;
     constructor(valueToLoad, delay) {
         super(null, null);
         this.valueToLoad = valueToLoad;
         this.delay = delay;
     }
-    /**
-     * @param {?=} params
-     * @param {?=} requestOptions
-     * @return {?}
-     */
     callWithObs(params = null, requestOptions = null) {
         return of(this.valueToLoad).pipe(delay(this.delay));
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    MockLinkField.prototype.valueToLoad;
-    /**
-     * @type {?}
-     * @private
-     */
-    MockLinkField.prototype.delay;
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+/*
+ * Public API Surface of micropermit
  */
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 export { CallLinkDirective, CallState, CallStatus, CallableLink, LinkField, LinkFieldContext, LinkFieldDirective, LinkFieldPagingSupport, LinkFieldPipe, LinkSerializer, MicroClient, MicroClientErrorIndicatorComponent, MicroClientLoadError, MicroClientLoadingIndicatorComponent, MicroClientModule, MicroError, MicroLinkValidateDirective, MicroObject, MicroObjectMetadata, MockLinkField, ParamUtils, SortInfo };
-//# sourceMappingURL=micropermit-client-angular.js.map
+//# sourceMappingURL=micropermit-client-angular.mjs.map