@coolon/angular-ui-powerups 0.0.1

package/bundles/coolon-angular-ui-powerups.umd.js

@@ -0,0 +1,3373 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('@angular/forms'), require('@angular/material'), require('@angular/platform-browser'), require('@angular/platform-browser/animations'), require('@coolon/pectin'), require('resize-observer-polyfill'), require('@angular/cdk/portal'), require('@coolon/pectin/lib/promise/deferred.class'), require('@angular/material/dialog'), require('@typescript-plus/fast-memoize-decorator'), require('lodash'), require('reflect-metadata'), require('@angular/router'), require('@coolon/typescript-utilities'), require('@typescript-plus/fast-memoize-decorator/dist/src')) :
+    typeof define === 'function' && define.amd ? define('@coolon/angular-ui-powerups', ['exports', '@angular/common', '@angular/core', '@angular/forms', '@angular/material', '@angular/platform-browser', '@angular/platform-browser/animations', '@coolon/pectin', 'resize-observer-polyfill', '@angular/cdk/portal', '@coolon/pectin/lib/promise/deferred.class', '@angular/material/dialog', '@typescript-plus/fast-memoize-decorator', 'lodash', 'reflect-metadata', '@angular/router', '@coolon/typescript-utilities', '@typescript-plus/fast-memoize-decorator/dist/src'], factory) :
+    (global = global || self, factory((global.coolon = global.coolon || {}, global.coolon['angular-ui-powerups'] = {}), global.ng.common, global.ng.core, global.ng.forms, global.ng.material, global.ng.platformBrowser, global.ng.platformBrowser.animations, global.pectin, global.ResizeObserver, global.ng.cdk.portal, global.deferred_class, global.ng.material.dialog, global.fastMemoizeDecorator, global.lodash, null, global.ng.router, global.typescriptUtilities, global.src));
+}(this, function (exports, common, core, forms, material, platformBrowser, animations, pectin, ResizeObserver, portal, deferred_class, dialog, fastMemoizeDecorator, lodash, reflectMetadata, router, typescriptUtilities, src) { 'use strict';
+
+    ResizeObserver = ResizeObserver && ResizeObserver.hasOwnProperty('default') ? ResizeObserver['default'] : ResizeObserver;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+        if (m) return m.call(o);
+        return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var DisposableComponent = /** @class */ (function (_super) {
+        __extends(DisposableComponent, _super);
+        function DisposableComponent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        /**
+         * @return {?}
+         */
+        DisposableComponent.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            this.dispose();
+        };
+        return DisposableComponent;
+    }(pectin.GarbageCollector));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var EMPTY_ERRORS = new pectin.MutableListModel().readonly;
+    /**
+     * @abstract
+     * @template T
+     */
+    var AbstractInputComponent = /** @class */ (function (_super) {
+        __extends(AbstractInputComponent, _super);
+        function AbstractInputComponent() {
+            var _this = _super.call(this) || this;
+            _this.focus = new core.EventEmitter();
+            _this.blur = new core.EventEmitter();
+            _this.enterKey = new core.EventEmitter();
+            _this.escapeKey = new core.EventEmitter();
+            /** @type {?} */
+            var self = _this;
+            _this.errorStateMatcher = {
+                isErrorState: /**
+                 * @param {?} control
+                 * @param {?} form
+                 * @return {?}
+                 */
+                function (control, form) {
+                    return self.hasErrors();
+                }
+            };
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.notifyClick = /**
+         * @return {?}
+         */
+        function () {
+            this.safelyInvoke(this.clickCommand);
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.notifyFocusIn = /**
+         * @return {?}
+         */
+        function () {
+            this.safelyInvoke(this.focusCommand);
+            this.focus.emit();
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.notifyFocusOut = /**
+         * @return {?}
+         */
+        function () {
+            this.safelyInvoke(this.blurCommand);
+            this.blur.emit();
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.notifyEnterKey = /**
+         * @return {?}
+         */
+        function () {
+            this.safelyInvoke(this.enterCommand);
+            this.enterKey.emit();
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.notifyEscapeKey = /**
+         * @return {?}
+         */
+        function () {
+            this.safelyInvoke(this.escapeCommand);
+            this.escapeKey.emit();
+        };
+        /**
+         * @protected
+         * @param {?} command
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.safelyInvoke = /**
+         * @protected
+         * @param {?} command
+         * @return {?}
+         */
+        function (command) {
+            if (command && command.isEnabled()) {
+                command.execute();
+            }
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+            // this._focused = this.valueModel['focused'] || new ValueHolder();
+        };
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.isEnabled = /**
+         * @return {?}
+         */
+        function () {
+            return this.enabled.value;
+        };
+        Object.defineProperty(AbstractInputComponent.prototype, "enabled", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // @ts-ignore
+                return ((/** @type {?} */ (this.valueModel))).enabled || pectin.Constant.TRUE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @return {?}
+         */
+        AbstractInputComponent.prototype.hasErrors = /**
+         * @return {?}
+         */
+        function () {
+            return !this.errorList.query().isEmpty();
+        };
+        Object.defineProperty(AbstractInputComponent.prototype, "errorList", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return ((/** @type {?} */ (this.valueModel))).errorList || EMPTY_ERRORS;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AbstractInputComponent.prototype, "firstError", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.hasErrors() ? this.errorList.value[0] : null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        AbstractInputComponent.propDecorators = {
+            valueModel: [{ type: core.Input }],
+            label: [{ type: core.Input }],
+            floatLabel: [{ type: core.Input }],
+            hint: [{ type: core.Input }],
+            placeholder: [{ type: core.Input }],
+            focusCommand: [{ type: core.Input, args: ['command.focus',] }],
+            blurCommand: [{ type: core.Input, args: ['command.blur',] }],
+            enterCommand: [{ type: core.Input, args: ['command.enter',] }],
+            escapeCommand: [{ type: core.Input, args: ['command.escape',] }],
+            clickCommand: [{ type: core.Input, args: ['command.click',] }],
+            focus: [{ type: core.Output }],
+            blur: [{ type: core.Output }],
+            enterKey: [{ type: core.Output }],
+            escapeKey: [{ type: core.Output }],
+            notifyClick: [{ type: core.HostListener, args: ['click',] }],
+            notifyFocusIn: [{ type: core.HostListener, args: ['focusin',] }],
+            notifyFocusOut: [{ type: core.HostListener, args: ['focusout',] }]
+        };
+        __decorate([
+            pectin.UseDelegate(),
+            __metadata("design:type", pectin.MutableValueModel)
+        ], AbstractInputComponent.prototype, "valueModel", void 0);
+        return AbstractInputComponent;
+    }(DisposableComponent));
+    if (false) {
+        /** @type {?} */
+        AbstractInputComponent.prototype.valueModel;
+        /** @type {?} */
+        AbstractInputComponent.prototype.label;
+        /** @type {?} */
+        AbstractInputComponent.prototype.floatLabel;
+        /** @type {?} */
+        AbstractInputComponent.prototype.hint;
+        /** @type {?} */
+        AbstractInputComponent.prototype.placeholder;
+        /** @type {?} */
+        AbstractInputComponent.prototype.focusCommand;
+        /** @type {?} */
+        AbstractInputComponent.prototype.blurCommand;
+        /** @type {?} */
+        AbstractInputComponent.prototype.enterCommand;
+        /** @type {?} */
+        AbstractInputComponent.prototype.escapeCommand;
+        /** @type {?} */
+        AbstractInputComponent.prototype.clickCommand;
+        /** @type {?} */
+        AbstractInputComponent.prototype.focus;
+        /** @type {?} */
+        AbstractInputComponent.prototype.blur;
+        /** @type {?} */
+        AbstractInputComponent.prototype.enterKey;
+        /** @type {?} */
+        AbstractInputComponent.prototype.escapeKey;
+        /** @type {?} */
+        AbstractInputComponent.prototype.errorStateMatcher;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var NumberInputComponent = /** @class */ (function (_super) {
+        __extends(NumberInputComponent, _super);
+        function NumberInputComponent() {
+            return _super.call(this) || this;
+        }
+        /**
+         * @return {?}
+         */
+        NumberInputComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        NumberInputComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-number-input',
+                        template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input type=\"number\"\n         matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n",
+                        styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        NumberInputComponent.ctorParameters = function () { return []; };
+        return NumberInputComponent;
+    }(AbstractInputComponent));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var CommandDirective = /** @class */ (function (_super) {
+        __extends(CommandDirective, _super);
+        function CommandDirective(elementRef) {
+            var _this = _super.call(this) || this;
+            _this.elementRef = elementRef;
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        CommandDirective.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+            pectin.assert.notNil(this.pectinCommand);
+        };
+        /**
+         * @return {?}
+         */
+        CommandDirective.prototype.ngAfterViewInit = /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            // for some reason mat-buttons kills the disabled host binding.  It works on a regular button but for now
+            // we need to do this.
+            var chain = pectin.Dsl.disposeWith(this).chain;
+            chain.value(this.pectinCommand.enabled).subscribe((/**
+             * @param {?} enabled
+             * @return {?}
+             */
+            function (enabled) {
+                if (enabled) {
+                    _this.elementRef.nativeElement.removeAttribute('disabled');
+                    if (_this.elementRef.nativeElement.tagName === 'A') {
+                        _this.elementRef.nativeElement.setAttribute('href', 'javascript:void');
+                    }
+                }
+                else {
+                    _this.elementRef.nativeElement.setAttribute('disabled', 'disabled');
+                    if (_this.elementRef.nativeElement.tagName === 'A') {
+                        _this.elementRef.nativeElement.removeAttribute('href');
+                    }
+                }
+            }));
+        };
+        /**
+         * @return {?}
+         */
+        CommandDirective.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            this.dispose();
+        };
+        /**
+         * @param {?} $event
+         * @return {?}
+         */
+        CommandDirective.prototype.notifyClick = /**
+         * @param {?} $event
+         * @return {?}
+         */
+        function ($event) {
+            $event.preventDefault();
+            $event.stopPropagation();
+            if (this.pectinCommand.isEnabled()) {
+                this.pectinCommand.execute({ event: $event });
+            }
+            else {
+                console.warn('disabled command clicked, ignoring.');
+            }
+        };
+        CommandDirective.decorators = [
+            { type: core.Directive, args: [{
+                        // tslint:disable-next-line:directive-selector
+                        selector: '[pectinCommand]'
+                    },] }
+        ];
+        /** @nocollapse */
+        CommandDirective.ctorParameters = function () { return [
+            { type: core.ElementRef, decorators: [{ type: core.Inject, args: [core.ElementRef,] }] }
+        ]; };
+        CommandDirective.propDecorators = {
+            pectinCommand: [{ type: core.Input }],
+            notifyClick: [{ type: core.HostListener, args: ['click', ['$event'],] }]
+        };
+        return CommandDirective;
+    }(pectin.GarbageCollector));
+    if (false) {
+        /** @type {?} */
+        CommandDirective.prototype.pectinCommand;
+        /**
+         * @type {?}
+         * @private
+         */
+        CommandDirective.prototype.elementRef;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var FocusBindingDirective = /** @class */ (function (_super) {
+        __extends(FocusBindingDirective, _super);
+        function FocusBindingDirective(el, ngZone, document) {
+            var _this = _super.call(this) || this;
+            _this.el = el;
+            _this.ngZone = ngZone;
+            // @see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642
+            _this.document = (/** @type {?} */ (document));
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.onFocusIn = /**
+         * @return {?}
+         */
+        function () {
+            this.pectinFocusBinding.focusCallbacks.notifyFocusIn();
+        };
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.onFocusOut = /**
+         * @return {?}
+         */
+        function () {
+            this.pectinFocusBinding.focusCallbacks.notifyFocusOut();
+        };
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.ngAfterViewInit = /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            // TODO: Make this also track the current enabled/disabled state.
+            var chain = pectin.Dsl.disposeWith(this).chain;
+            chain.value(this.pectinFocusBinding.focused).subscribe((/**
+             * @param {?} focused
+             * @return {?}
+             */
+            function (focused) {
+                if (focused && !_this.alreadyHasFocus()) {
+                    _this.tryAndFocus();
+                }
+            }));
+        };
+        // Hook method for debugging via tracing.
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.alreadyHasFocus = 
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        function () {
+            return this.isFocused(this.focusTarget);
+        };
+        // Hook method for debugging via tracing.
+        // Hook method for debugging via tracing.
+        /**
+         * @param {?} element
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.isFocused = 
+        // Hook method for debugging via tracing.
+        /**
+         * @param {?} element
+         * @return {?}
+         */
+        function (element) {
+            return this.document.activeElement === element;
+        };
+        /**
+         * @param {?=} retries
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.tryAndFocus = /**
+         * @param {?=} retries
+         * @return {?}
+         */
+        function (retries) {
+            var _this = this;
+            if (retries === void 0) { retries = 5; }
+            if (this.modelShouldStillHaveFocus() && this.canFocus()) {
+                if (!this.alreadyHasFocus()) {
+                    this.focusTarget.focus();
+                }
+                // if we didn't get the focus we try again later.
+                if (!this.alreadyHasFocus()) {
+                    pectin.Logger.get(this).log("focus failed, trying " + retries + " more times");
+                    if (retries > 0) {
+                        // try again on the next paint
+                        // TODO: is there an angular way of doing this without calling a window function.
+                        requestAnimationFrame((/**
+                         * @return {?}
+                         */
+                        function () {
+                            _this.tryAndFocus(retries - 1);
+                        }));
+                    }
+                    else {
+                        pectin.Logger.get(this).warn("Tried to focus but gave up as the component wasn't enabled or visible.");
+                    }
+                }
+            }
+        };
+        Object.defineProperty(FocusBindingDirective.prototype, "focusTarget", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.focusBindingTarget || this.el.nativeElement;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        // Hook method for debugging via tracing.
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.modelShouldStillHaveFocus = 
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        function () {
+            return this.pectinFocusBinding.focused.value;
+        };
+        // Hook method for debugging via tracing.
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        FocusBindingDirective.prototype.canFocus = 
+        // Hook method for debugging via tracing.
+        /**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var dimension = this.focusTarget.getBoundingClientRect();
+            /** @type {?} */
+            var hasSize = dimension.height >= 0 && dimension.height >= 0;
+            // tslint:disable-next-line:no-string-literal
+            return hasSize && !this.focusTarget['disabled'];
+        };
+        FocusBindingDirective.decorators = [
+            { type: core.Directive, args: [{
+                        // tslint:disable-next-line:directive-selector
+                        selector: '[pectinFocusBinding]'
+                    },] }
+        ];
+        /** @nocollapse */
+        FocusBindingDirective.ctorParameters = function () { return [
+            { type: core.ElementRef, decorators: [{ type: core.Inject, args: [core.ElementRef,] }] },
+            { type: core.NgZone, decorators: [{ type: core.Inject, args: [core.NgZone,] }] },
+            { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
+        ]; };
+        FocusBindingDirective.propDecorators = {
+            pectinFocusBinding: [{ type: core.Input }],
+            focusBindingTarget: [{ type: core.Input }],
+            onFocusIn: [{ type: core.HostListener, args: ['focusin',] }],
+            onFocusOut: [{ type: core.HostListener, args: ['focusout',] }]
+        };
+        return FocusBindingDirective;
+    }(DisposableComponent));
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        FocusBindingDirective.prototype.document;
+        /** @type {?} */
+        FocusBindingDirective.prototype.pectinFocusBinding;
+        /** @type {?} */
+        FocusBindingDirective.prototype.focusBindingTarget;
+        /**
+         * @type {?}
+         * @private
+         */
+        FocusBindingDirective.prototype.el;
+        /**
+         * @type {?}
+         * @private
+         */
+        FocusBindingDirective.prototype.ngZone;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var StringInputComponent = /** @class */ (function (_super) {
+        __extends(StringInputComponent, _super);
+        function StringInputComponent() {
+            return _super.call(this) || this;
+        }
+        /**
+         * @return {?}
+         */
+        StringInputComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        StringInputComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-string-input',
+                        template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n\n",
+                        styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        StringInputComponent.ctorParameters = function () { return []; };
+        return StringInputComponent;
+    }(AbstractInputComponent));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PasswordInputComponent = /** @class */ (function (_super) {
+        __extends(PasswordInputComponent, _super);
+        function PasswordInputComponent() {
+            return _super.call(this) || this;
+        }
+        /**
+         * @return {?}
+         */
+        PasswordInputComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        PasswordInputComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-password-input',
+                        template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <input type=\"password\"\n         matInput\n         placeholder=\"{{placeholder}}\"\n         [(ngModel)]=\"valueModel.value\"\n         [disabled]=\"!enabled.value\"\n         (keydown.enter)=\"notifyEnterKey()\"\n         (keydown.escape)=\"notifyEscapeKey()\"\n         [pectinFocusBinding]=\"valueModel\"\n         [errorStateMatcher]=\"errorStateMatcher\"\n  >\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n\n",
+                        styles: [":host{display:block}input,mat-form-field{width:100%}input mat-hint.faux-error,mat-form-field mat-hint.faux-error{color:#f44336}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        PasswordInputComponent.ctorParameters = function () { return []; };
+        return PasswordInputComponent;
+    }(AbstractInputComponent));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     */
+    var SelectInputComponent = /** @class */ (function (_super) {
+        __extends(SelectInputComponent, _super);
+        function SelectInputComponent() {
+            var _this = _super.call(this) || this;
+            _this.optionLabelFormat = (/**
+             * @param {?} option
+             * @return {?}
+             */
+            function (option) { return (option && _this.optionLabel) ? option[_this.optionLabel] : option; });
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        SelectInputComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        SelectInputComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-select-input',
+                        template: "<mat-form-field appearance=\"standard\" [floatLabel]=\"floatLabel\">\n  <mat-label *ngIf=\"label\">{{label}}</mat-label>\n  <mat-select placeholder=\"{{placeholder}}\"\n              [(ngModel)]=\"valueModel.value\"\n              [disabled]=\"!enabled.value\"\n              (keydown.enter)=\"notifyEnterKey()\"\n              (keydown.escape)=\"notifyEscapeKey()\"\n              [pectinFocusBinding]=\"valueModel\"\n              [errorStateMatcher]=\"errorStateMatcher\"\n  >\n    <mat-option *ngFor=\"let option of optionsModel.value\" [value]=\"option\">{{optionLabelFormat(option)}}\n    </mat-option>\n  </mat-select>\n  <mat-hint *ngIf=\"hint\">{{hint}}</mat-hint>\n  <mat-error *ngIf=\"hasErrors\">{{firstError}}</mat-error>\n</mat-form-field>\n",
+                        styles: [":host{display:inline-block}mat-form-field{width:100%}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        SelectInputComponent.ctorParameters = function () { return []; };
+        SelectInputComponent.propDecorators = {
+            optionsModel: [{ type: core.Input }],
+            options: [{ type: core.Input }],
+            optionLabel: [{ type: core.Input }],
+            optionLabelFormat: [{ type: core.Input }]
+        };
+        __decorate([
+            pectin.UseDelegate(),
+            __metadata("design:type", pectin.ListModel)
+        ], SelectInputComponent.prototype, "optionsModel", void 0);
+        __decorate([
+            pectin.StoreInListModel('optionsModel'),
+            __metadata("design:type", Array)
+        ], SelectInputComponent.prototype, "options", void 0);
+        return SelectInputComponent;
+    }(AbstractInputComponent));
+    if (false) {
+        /** @type {?} */
+        SelectInputComponent.prototype.optionsModel;
+        /** @type {?} */
+        SelectInputComponent.prototype.options;
+        /** @type {?} */
+        SelectInputComponent.prototype.optionLabel;
+        /** @type {?} */
+        SelectInputComponent.prototype.optionLabelFormat;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var AngularUiPowerupsModule = /** @class */ (function () {
+        function AngularUiPowerupsModule() {
+        }
+        AngularUiPowerupsModule.decorators = [
+            { type: core.NgModule, args: [{
+                        declarations: [
+                            CommandDirective,
+                            FocusBindingDirective,
+                            NumberInputComponent,
+                            StringInputComponent,
+                            PasswordInputComponent,
+                            SelectInputComponent,
+                        ],
+                        imports: [
+                            common.CommonModule,
+                            platformBrowser.BrowserModule,
+                            animations.BrowserAnimationsModule,
+                            forms.FormsModule,
+                            material.MatInputModule,
+                            material.MatFormFieldModule,
+                            material.MatSelectModule
+                        ],
+                        exports: [
+                            CommandDirective,
+                            FocusBindingDirective,
+                            NumberInputComponent,
+                            StringInputComponent,
+                            PasswordInputComponent,
+                            SelectInputComponent,
+                        ]
+                    },] }
+        ];
+        return AngularUiPowerupsModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var Dimension = /** @class */ (function () {
+        function Dimension(width, height) {
+            this.width = width;
+            this.height = height;
+        }
+        return Dimension;
+    }());
+    if (false) {
+        /** @type {?} */
+        Dimension.prototype.width;
+        /** @type {?} */
+        Dimension.prototype.height;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var Point = /** @class */ (function () {
+        function Point(x, y) {
+            this.x = x;
+            this.y = y;
+        }
+        /**
+         * @param {?} data
+         * @return {?}
+         */
+        Point.from = /**
+         * @param {?} data
+         * @return {?}
+         */
+        function (data) {
+            return new Point(data.x, data.y);
+        };
+        /**
+         * @param {?} x
+         * @param {?} y
+         * @return {?}
+         */
+        Point.prototype.translate = /**
+         * @param {?} x
+         * @param {?} y
+         * @return {?}
+         */
+        function (x, y) {
+            return new Point(this.x + x, this.y + y);
+        };
+        return Point;
+    }());
+    if (false) {
+        /** @type {?} */
+        Point.prototype.x;
+        /** @type {?} */
+        Point.prototype.y;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    exports.Bounds = /** @class */ (function (_super) {
+        __extends(Bounds, _super);
+        function Bounds(top, left, width, height) {
+            var _this = _super.call(this, width, height) || this;
+            _this.top = top;
+            _this.left = left;
+            _this.width = width;
+            _this.height = height;
+            return _this;
+        }
+        /**
+         * @param {?} point
+         * @return {?}
+         */
+        Bounds.prototype.relativePositionOf = /**
+         * @param {?} point
+         * @return {?}
+         */
+        function (point) {
+            if (point instanceof MouseEvent) {
+                return new Point(point.clientX - this.left, point.clientY - this.top);
+            }
+            else {
+                return new Point(point.x - this.left, point.y - this.top);
+            }
+        };
+        return Bounds;
+    }(Dimension));
+    if (false) {
+        /** @type {?} */
+        exports.Bounds.prototype.top;
+        /** @type {?} */
+        exports.Bounds.prototype.left;
+        /** @type {?} */
+        exports.Bounds.prototype.width;
+        /** @type {?} */
+        exports.Bounds.prototype.height;
+    }
+    (function (Bounds) {
+        /**
+         * @param {?} element
+         * @return {?}
+         */
+        function ofElement(element) {
+            /** @type {?} */
+            var rect = element.getBoundingClientRect();
+            return new Bounds(rect.top, rect.left, rect.width, rect.height);
+        }
+        Bounds.ofElement = ofElement;
+    })(exports.Bounds || (exports.Bounds = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var ResizeAwareComponent = /** @class */ (function (_super) {
+        __extends(ResizeAwareComponent, _super);
+        function ResizeAwareComponent(elementRef, ngZone) {
+            var _this = _super.call(this) || this;
+            _this.elementRef = elementRef;
+            _this.ngZone = ngZone;
+            _this._boundsModel = new pectin.ValueHolder(new exports.Bounds(0, 0, 0, 0));
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        ResizeAwareComponent.prototype.ngAfterViewInit = /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            this.updateBounds();
+            /** @type {?} */
+            var element = this.elementRef.nativeElement;
+            /** @type {?} */
+            var ro = new ResizeObserver((/**
+             * @param {?} entries
+             * @param {?} observer
+             * @return {?}
+             */
+            function (entries, observer) {
+                _this.ngZone.run((/**
+                 * @return {?}
+                 */
+                function () { return _this.updateBounds(); }));
+            }));
+            ro.observe(element);
+            this.onDispose((/**
+             * @return {?}
+             */
+            function () { return ro.disconnect(); }));
+        };
+        Object.defineProperty(ResizeAwareComponent.prototype, "boundsModel", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._boundsModel.readonly;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ResizeAwareComponent.prototype, "nativeElement", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.elementRef.nativeElement;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        // TODO: Make this handle body scroll
+        // TODO: Make this handle body scroll
+        /**
+         * @param {?} point
+         * @return {?}
+         */
+        ResizeAwareComponent.prototype.relativePositionOf = 
+        // TODO: Make this handle body scroll
+        /**
+         * @param {?} point
+         * @return {?}
+         */
+        function (point) {
+            return this.bounds.relativePositionOf(point);
+        };
+        Object.defineProperty(ResizeAwareComponent.prototype, "bounds", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._boundsModel.value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @private
+         * @return {?}
+         */
+        ResizeAwareComponent.prototype.updateBounds = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            this._boundsModel.value = exports.Bounds.ofElement(this.nativeElement);
+        };
+        return ResizeAwareComponent;
+    }(DisposableComponent));
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        ResizeAwareComponent.prototype._boundsModel;
+        /**
+         * @type {?}
+         * @protected
+         */
+        ResizeAwareComponent.prototype.elementRef;
+        /**
+         * @type {?}
+         * @protected
+         */
+        ResizeAwareComponent.prototype.ngZone;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template D, R, E
+     */
+    var   /**
+     * @template D, R, E
+     */
+    AbstractActivity = /** @class */ (function (_super) {
+        __extends(AbstractActivity, _super);
+        function AbstractActivity() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._doneListeners = new pectin.EventListenerList();
+            _this._cancelListeners = new pectin.EventListenerList();
+            _this._finishListeners = new pectin.EventListenerList();
+            _this._busyModel = new pectin.DelegatingValueModel().withDefault(false);
+            return _this;
+        }
+        /**
+         * @param {?} callback
+         * @return {?}
+         */
+        AbstractActivity.prototype.onDone = /**
+         * @param {?} callback
+         * @return {?}
+         */
+        function (callback) {
+            this._doneListeners.add(callback);
+        };
+        /**
+         * @param {?} callback
+         * @return {?}
+         */
+        AbstractActivity.prototype.onCancel = /**
+         * @param {?} callback
+         * @return {?}
+         */
+        function (callback) {
+            this._cancelListeners.add(callback);
+        };
+        /**
+         * @param {?=} result
+         * @return {?}
+         */
+        AbstractActivity.prototype.done = /**
+         * @param {?=} result
+         * @return {?}
+         */
+        function (result) {
+            var _this = this;
+            return this._doneListeners
+                .fireAndWait((/**
+             * @param {?} l
+             * @return {?}
+             */
+            function (l) { return l(result); }))
+                .finally((/**
+             * @return {?}
+             */
+            function () { return _this.finalizeAndDispose(); }));
+        };
+        /**
+         * @param {?=} error
+         * @return {?}
+         */
+        AbstractActivity.prototype.cancel = /**
+         * @param {?=} error
+         * @return {?}
+         */
+        function (error) {
+            var _this = this;
+            return this._cancelListeners
+                .fireAndWait((/**
+             * @param {?} l
+             * @return {?}
+             */
+            function (l) { return l(error); }))
+                .finally((/**
+             * @return {?}
+             */
+            function () { return _this.finalizeAndDispose(); }));
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        AbstractActivity.prototype.finalizeAndDispose = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            // this._activeModel.value = false;
+            this._finishListeners.fire((/**
+             * @param {?} l
+             * @return {?}
+             */
+            function (l) { return l(); }));
+            // this._interactionContext = null;
+            // this._initialized = false;
+            [
+                this._finishListeners,
+                this._doneListeners,
+                this._cancelListeners
+            ].forEach((/**
+             * @param {?} l
+             * @return {?}
+             */
+            function (l) { return l.dispose(); }));
+        };
+        Object.defineProperty(AbstractActivity.prototype, "busy", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._busyModel.readonly;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @param {?} busyModel
+         * @return {?}
+         */
+        AbstractActivity.prototype.busyWhile = /**
+         * @param {?} busyModel
+         * @return {?}
+         */
+        function (busyModel) {
+            this._busyModel.setDelegate(busyModel);
+        };
+        /**
+         * @return {?}
+         */
+        AbstractActivity.prototype.isBusy = /**
+         * @return {?}
+         */
+        function () {
+            return this._busyModel.value;
+        };
+        return AbstractActivity;
+    }(DisposableComponent));
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractActivity.prototype._doneListeners;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractActivity.prototype._cancelListeners;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractActivity.prototype._finishListeners;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractActivity.prototype._busyModel;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var ACTIVITY_DATA = new core.InjectionToken('InteractionActivityData');
+    /**
+     * @record
+     * @template D, R, E
+     */
+    function Activity() { }
+    if (false) {
+        /** @type {?} */
+        Activity.prototype.busy;
+        /**
+         * @param {?} callback
+         * @return {?}
+         */
+        Activity.prototype.onDone = function (callback) { };
+        /**
+         * @param {?} callback
+         * @return {?}
+         */
+        Activity.prototype.onCancel = function (callback) { };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     */
+    function Alert() { }
+    if (false) {
+        /**
+         * @return {?}
+         */
+        Alert.prototype.title = function () { };
+        /**
+         * @return {?}
+         */
+        Alert.prototype.content = function () { };
+        /**
+         * @return {?}
+         */
+        Alert.prototype.ok = function () { };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     */
+    function Confirm() { }
+    if (false) {
+        /** @type {?|undefined} */
+        Confirm.prototype.destructive;
+        /**
+         * @return {?}
+         */
+        Confirm.prototype.cancel = function () { };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var INTERACTION_CONTEXT = new core.InjectionToken('InteractionContext');
+    /**
+     * @abstract
+     */
+    var   /**
+     * @abstract
+     */
+    InteractionContext = /** @class */ (function () {
+        function InteractionContext() {
+        }
+        return InteractionContext;
+    }());
+    if (false) {
+        /**
+         * @abstract
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        InteractionContext.prototype.startActivity = function (activityType, data) { };
+        /**
+         * @abstract
+         * @param {?} confirm
+         * @return {?}
+         */
+        InteractionContext.prototype.confirm = function (confirm) { };
+        /**
+         * @abstract
+         * @param {?} alert
+         * @return {?}
+         */
+        InteractionContext.prototype.alert = function (alert) { };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var AlertDialogComponent = /** @class */ (function (_super) {
+        __extends(AlertDialogComponent, _super);
+        function AlertDialogComponent(alert) {
+            var _this = _super.call(this) || this;
+            _this.alert = alert;
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        AlertDialogComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        AlertDialogComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-alert-dialog',
+                        template: "<h3 matDialogTitle *ngIf=\"alert.title\">{{alert.title()}}</h3>\n<div matDialogContent>\n  <p *ngFor=\"let line of alert.content()\">{{line}}</p>\n</div>\n<p matDialogActions>\n  <button mat-raised-button color=\"primary\" (click)=\"done()\">{{alert.ok()}}</button>\n</p>\n",
+                        styles: [":host{display:block;padding:var(--default-padding)}.mat-dialog-actions{justify-content:flex-end}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        AlertDialogComponent.ctorParameters = function () { return [
+            { type: undefined, decorators: [{ type: core.Inject, args: [ACTIVITY_DATA,] }] }
+        ]; };
+        return AlertDialogComponent;
+    }(AbstractActivity));
+    if (false) {
+        /** @type {?} */
+        AlertDialogComponent.prototype.alert;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var ConfirmationDialogComponent = /** @class */ (function (_super) {
+        __extends(ConfirmationDialogComponent, _super);
+        function ConfirmationDialogComponent(confirm) {
+            var _this = _super.call(this) || this;
+            _this.confirm = confirm;
+            pectin.assert.notNil(confirm);
+            console.log(confirm);
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        ConfirmationDialogComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        /**
+         * @return {?}
+         */
+        ConfirmationDialogComponent.prototype.isDestructive = /**
+         * @return {?}
+         */
+        function () {
+            return this.confirm.destructive && this.confirm.destructive();
+        };
+        ConfirmationDialogComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-confirmation-dialog',
+                        template: "<h3 matDialogTitle *ngIf=\"confirm.title\">{{confirm.title()}}</h3>\n<div matDialogContent>\n  <p *ngFor=\"let line of confirm.content()\">{{line}}</p>\n</div>\n<p matDialogActions>\n  <button mat-button (click)=\"cancel()\">{{confirm.cancel()}}</button>\n  <button mat-raised-button [color]=\"isDestructive() ? 'warn' : 'primary'\" (click)=\"done(true)\">{{confirm.ok()}}</button>\n</p>\n\n",
+                        styles: [":host{display:block;padding:var(--default-padding)}.mat-dialog-actions{justify-content:flex-end}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        ConfirmationDialogComponent.ctorParameters = function () { return [
+            { type: undefined, decorators: [{ type: core.Inject, args: [ACTIVITY_DATA,] }] }
+        ]; };
+        return ConfirmationDialogComponent;
+    }(AbstractActivity));
+    if (false) {
+        /** @type {?} */
+        ConfirmationDialogComponent.prototype.confirm;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    exports.ActivityContainerComponent = /** @class */ (function (_super) {
+        __extends(ActivityContainerComponent, _super);
+        function ActivityContainerComponent() {
+            var _this = _super.call(this) || this;
+            _this.activityTabs = new pectin.MutableListModel();
+            _this.obsoleteTabs = [];
+            return _this;
+        }
+        /**
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        /**
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.ngAfterViewInit = /**
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            var observe = pectin.Dsl.disposeWith(this).observe;
+            observe.valuesFrom(this.tabs.animationDone).subscribe((/**
+             * @return {?}
+             */
+            function () { return _this.cleanUpTabs(); }));
+        };
+        /**
+         * @template D, R, E
+         * @param {?} options
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.initialise = /**
+         * @template D, R, E
+         * @param {?} options
+         * @return {?}
+         */
+        function (options) {
+            this.initialActivity = __assign({}, options, { interactionContext: this });
+        };
+        /**
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.startActivity = /**
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        function (activityType, data) {
+            var _this = this;
+            /** @type {?} */
+            var deferred = deferred_class.Deferred.defer();
+            /** @type {?} */
+            var context = {
+                interactionContext: this,
+                activityClass: activityType,
+                activityData: data,
+                onDone: deferred.resolve,
+                onCancel: deferred.reject
+            };
+            this.activityTabs.push(context);
+            this.tabs.selectedIndex = this.activityTabs.length;
+            return deferred.promise.finally((/**
+             * @return {?}
+             */
+            function () {
+                _this.obsoleteTabs.push(context);
+                _this.tabs.selectedIndex = _this.activityTabs.length - 1;
+            }));
+        };
+        /**
+         * @param {?} alert
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.alert = /**
+         * @param {?} alert
+         * @return {?}
+         */
+        function (alert) {
+            return this.startActivity(AlertDialogComponent, alert);
+        };
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.confirm = /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        function (confirm) {
+            return this.startActivity(ConfirmationDialogComponent, confirm);
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        ActivityContainerComponent.prototype.cleanUpTabs = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            this.activityTabs.value = this.activityTabs.value.filter((/**
+             * @param {?} tab
+             * @return {?}
+             */
+            function (tab) {
+                return !_this.obsoleteTabs.includes(tab);
+            }));
+        };
+        ActivityContainerComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-activity-container',
+                        template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"true\">\n  <mat-tab>\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"initialActivity\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n  <mat-tab *ngFor=\"let tab of activityTabs.value\">\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"tab\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
+                        styles: [":host{display:block}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        ActivityContainerComponent.ctorParameters = function () { return []; };
+        ActivityContainerComponent.propDecorators = {
+            parentInteractionContext: [{ type: core.Input }],
+            initialActivity: [{ type: core.Input }],
+            tabs: [{ type: core.ViewChild, args: ['tabs', { static: true },] }]
+        };
+        return ActivityContainerComponent;
+    }(DisposableComponent));
+    if (false) {
+        /** @type {?} */
+        exports.ActivityContainerComponent.prototype.parentInteractionContext;
+        /** @type {?} */
+        exports.ActivityContainerComponent.prototype.initialActivity;
+        /** @type {?} */
+        exports.ActivityContainerComponent.prototype.tabs;
+        /** @type {?} */
+        exports.ActivityContainerComponent.prototype.activityTabs;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ActivityContainerComponent.prototype.obsoleteTabs;
+    }
+    (function (ActivityContainerComponent) {
+        /**
+         * @record
+         * @template D, R, E
+         */
+        function ActivityContext() { }
+        ActivityContainerComponent.ActivityContext = ActivityContext;
+        if (false) {
+            /** @type {?} */
+            ActivityContext.prototype.activityClass;
+            /** @type {?} */
+            ActivityContext.prototype.activityData;
+            /** @type {?} */
+            ActivityContext.prototype.onDone;
+            /** @type {?} */
+            ActivityContext.prototype.onCancel;
+        }
+    })(exports.ActivityContainerComponent || (exports.ActivityContainerComponent = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template D, R, E
+     */
+    exports.ActivityOutletComponent = /** @class */ (function () {
+        function ActivityOutletComponent(componentFactoryResolver, viewContainerRef, injector) {
+            this.componentFactoryResolver = componentFactoryResolver;
+            this.viewContainerRef = viewContainerRef;
+            this.injector = injector;
+        }
+        Object.defineProperty(ActivityOutletComponent.prototype, "activityContext", {
+            set: /**
+             * @param {?} activityContext
+             * @return {?}
+             */
+            function (activityContext) {
+                this.loadActivity(activityContext);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ;
+        /**
+         * @return {?}
+         */
+        ActivityOutletComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        /**
+         * @param {?} activityContext
+         * @return {?}
+         */
+        ActivityOutletComponent.prototype.loadActivity = /**
+         * @param {?} activityContext
+         * @return {?}
+         */
+        function (activityContext) {
+            /** @type {?} */
+            var injector = core.Injector.create({
+                providers: [
+                    {
+                        provide: InteractionContext,
+                        useValue: this
+                    },
+                    { provide: ACTIVITY_DATA, useValue: activityContext.activityData }
+                ],
+                parent: this.injector
+            });
+            /** @type {?} */
+            var componentFactory = this.componentFactoryResolver.resolveComponentFactory(activityContext.activityClass);
+            this.viewContainerRef.clear();
+            this.activityComponent = this.viewContainerRef.createComponent(componentFactory, 0, injector);
+            this.activityComponent.instance.onDone(activityContext.onDone);
+            this.activityComponent.instance.onCancel(activityContext.onCancel);
+        };
+        /**
+         * @param {?} alert
+         * @return {?}
+         */
+        ActivityOutletComponent.prototype.alert = /**
+         * @param {?} alert
+         * @return {?}
+         */
+        function (alert) {
+            return this.interactionContext.alert(alert);
+        };
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        ActivityOutletComponent.prototype.confirm = /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        function (confirm) {
+            return this.interactionContext.confirm(confirm);
+        };
+        /**
+         * @template D1, R1, E1
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        ActivityOutletComponent.prototype.startActivity = /**
+         * @template D1, R1, E1
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        function (activityType, data) {
+            return this.interactionContext.startActivity(activityType, data);
+        };
+        ActivityOutletComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-activity-outlet',
+                        template: '',
+                        styles: [":host{display:block}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        ActivityOutletComponent.ctorParameters = function () { return [
+            { type: core.ComponentFactoryResolver },
+            { type: core.ViewContainerRef },
+            { type: core.Injector }
+        ]; };
+        ActivityOutletComponent.propDecorators = {
+            interactionContext: [{ type: core.Input }],
+            activityContext: [{ type: core.Input }]
+        };
+        return ActivityOutletComponent;
+    }());
+    if (false) {
+        /** @type {?} */
+        exports.ActivityOutletComponent.prototype.interactionContext;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ActivityOutletComponent.prototype.activityComponent;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ActivityOutletComponent.prototype.componentFactoryResolver;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ActivityOutletComponent.prototype.viewContainerRef;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.ActivityOutletComponent.prototype.injector;
+        /* Skipping unhandled member: ;*/
+    }
+    (function (ActivityOutletComponent) {
+        /**
+         * @template D, R, E
+         */
+        var /**
+         * @template D, R, E
+         */
+        OutletInteractionContext = /** @class */ (function () {
+            function OutletInteractionContext(context) {
+                this.context = context;
+            }
+            /**
+             * @param {?} alert
+             * @return {?}
+             */
+            OutletInteractionContext.prototype.alert = /**
+             * @param {?} alert
+             * @return {?}
+             */
+            function (alert) {
+                return pectin.lang.notImplemented();
+            };
+            /**
+             * @param {?} confirm
+             * @return {?}
+             */
+            OutletInteractionContext.prototype.confirm = /**
+             * @param {?} confirm
+             * @return {?}
+             */
+            function (confirm) {
+                return pectin.lang.notImplemented();
+            };
+            /**
+             * @template D1, R1, E1
+             * @param {?} activityType
+             * @param {?=} data
+             * @return {?}
+             */
+            OutletInteractionContext.prototype.startActivity = /**
+             * @template D1, R1, E1
+             * @param {?} activityType
+             * @param {?=} data
+             * @return {?}
+             */
+            function (activityType, data) {
+                return pectin.lang.notImplemented();
+            };
+            return OutletInteractionContext;
+        }());
+        ActivityOutletComponent.OutletInteractionContext = OutletInteractionContext;
+        if (false) {
+            /**
+             * @type {?}
+             * @private
+             */
+            OutletInteractionContext.prototype.context;
+        }
+    })(exports.ActivityOutletComponent || (exports.ActivityOutletComponent = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var DialogInteractionService = /** @class */ (function (_super) {
+        __extends(DialogInteractionService, _super);
+        function DialogInteractionService(dialogService) {
+            var _this = _super.call(this) || this;
+            _this.dialogService = dialogService;
+            return _this;
+        }
+        /**
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        DialogInteractionService.prototype.startActivity = /**
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?=} data
+         * @return {?}
+         */
+        function (activityType, data) {
+            return this._startActivity(activityType, data);
+        };
+        /**
+         * @private
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?} data
+         * @param {?=} disableClose
+         * @return {?}
+         */
+        DialogInteractionService.prototype._startActivity = /**
+         * @private
+         * @template D, R, E
+         * @param {?} activityType
+         * @param {?} data
+         * @param {?=} disableClose
+         * @return {?}
+         */
+        function (activityType, data, disableClose) {
+            var _this = this;
+            if (disableClose === void 0) { disableClose = true; }
+            /** @type {?} */
+            var config = {
+                data: data,
+                disableClose: disableClose,
+                panelClass: 'dialog-interaction-service',
+                autoFocus: false
+            };
+            /** @type {?} */
+            var matDialogRef = (/** @type {?} */ (this.dialogService.open(exports.ActivityContainerComponent, config)));
+            return new Promise((/**
+             * @param {?} resolve
+             * @param {?} reject
+             * @return {?}
+             */
+            function (resolve, reject) {
+                /** @type {?} */
+                var activityContainer = matDialogRef.componentInstance;
+                activityContainer.parentInteractionContext = _this;
+                activityContainer.initialise({
+                    activityClass: activityType,
+                    activityData: data,
+                    onDone: /**
+                     * @param {?} result
+                     * @return {?}
+                     */
+                    function (result) {
+                        resolve(result);
+                        matDialogRef.close(result);
+                    },
+                    onCancel: /**
+                     * @param {?} error
+                     * @return {?}
+                     */
+                    function (error) {
+                        reject(error);
+                        matDialogRef.close(error);
+                    }
+                });
+                matDialogRef.updateSize();
+            }));
+        };
+        /**
+         * @param {?} alert
+         * @return {?}
+         */
+        DialogInteractionService.prototype.alert = /**
+         * @param {?} alert
+         * @return {?}
+         */
+        function (alert) {
+            return this._startActivity(AlertDialogComponent, alert, false);
+        };
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        DialogInteractionService.prototype.confirm = /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        function (confirm) {
+            return this._startActivity(ConfirmationDialogComponent, confirm, true);
+        };
+        DialogInteractionService.decorators = [
+            { type: core.Injectable, args: [{
+                        providedIn: 'root'
+                    },] }
+        ];
+        /** @nocollapse */
+        DialogInteractionService.ctorParameters = function () { return [
+            { type: material.MatDialog }
+        ]; };
+        /** @nocollapse */ DialogInteractionService.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function DialogInteractionService_Factory() { return new DialogInteractionService(core.ɵɵinject(dialog.MatDialog)); }, token: DialogInteractionService, providedIn: "root" });
+        return DialogInteractionService;
+    }(InteractionContext));
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        DialogInteractionService.prototype.dialogService;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var InteractionModule = /** @class */ (function () {
+        function InteractionModule() {
+        }
+        InteractionModule.decorators = [
+            { type: core.NgModule, args: [{
+                        imports: [
+                            common.CommonModule,
+                            material.MatButtonModule,
+                            material.MatDialogModule,
+                            material.MatTabsModule,
+                            portal.PortalModule
+                        ],
+                        declarations: [
+                            exports.ActivityContainerComponent,
+                            ConfirmationDialogComponent,
+                            AlertDialogComponent,
+                            exports.ActivityOutletComponent
+                        ],
+                        entryComponents: [
+                            exports.ActivityContainerComponent,
+                            ConfirmationDialogComponent,
+                            AlertDialogComponent
+                        ],
+                        providers: [
+                            DialogInteractionService
+                        ]
+                    },] }
+        ];
+        return InteractionModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template R, E
+     */
+    function Result() { }
+    (function (Result) {
+        /**
+         * @record
+         * @template R, E
+         */
+        function Callback() { }
+        Result.Callback = Callback;
+        if (false) {
+            /** @type {?} */
+            Callback.prototype.then;
+            /** @type {?} */
+            Callback.prototype.catch;
+        }
+    })(Result || (Result = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template D, R, E
+     */
+    function ActivityOutletContext() { }
+    if (false) {
+        /** @type {?} */
+        ActivityOutletContext.prototype.interactionContext;
+        /** @type {?} */
+        ActivityOutletContext.prototype.activityClass;
+        /** @type {?} */
+        ActivityOutletContext.prototype.activityData;
+        /** @type {?} */
+        ActivityOutletContext.prototype.onDone;
+        /** @type {?} */
+        ActivityOutletContext.prototype.onCancel;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    function Place(options) {
+        return (/**
+         * @param {?} target
+         * @return {?}
+         */
+        function (target) {
+            Reflect.defineMetadata('place.options', options, target);
+        });
+    }
+    (function (Place) {
+        /**
+         * @record
+         */
+        function Options() { }
+        Place.Options = Options;
+        if (false) {
+            /** @type {?} */
+            Options.prototype.path;
+            /** @type {?} */
+            Options.prototype.title;
+            /** @type {?|undefined} */
+            Options.prototype.authenticate;
+        }
+        var Descriptor = /** @class */ (function () {
+            function Descriptor(placeClass, options) {
+                pectin.assert.notNil(options);
+                this.path = options.path;
+                this.title = options.title;
+                this.authenticate = lodash.isNil(options.authenticate) || options.authenticate;
+            }
+            return Descriptor;
+        }());
+        Place.Descriptor = Descriptor;
+        if (false) {
+            /** @type {?} */
+            Descriptor.prototype.path;
+            /** @type {?} */
+            Descriptor.prototype.authenticate;
+            /** @type {?} */
+            Descriptor.prototype.title;
+        }
+        /**
+         * @param {?} klass
+         * @return {?}
+         */
+        function getDescriptor(klass) {
+            /** @type {?} */
+            var placeOptions = Reflect.getMetadata('place.options', klass);
+            return new Descriptor(klass, placeOptions);
+        }
+        Place.getDescriptor = getDescriptor;
+    })(Place || (Place = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template T
+     */
+    function ResolvedParameter() { }
+    if (false) {
+        /** @type {?} */
+        ResolvedParameter.prototype.parameter;
+        /** @type {?} */
+        ResolvedParameter.prototype.resolvedValue;
+    }
+    var ResolvedParameters = /** @class */ (function () {
+        function ResolvedParameters(parameters) {
+            this.parameters = parameters;
+        }
+        /**
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        ResolvedParameters.prototype.get = /**
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        function (parameter) {
+            /** @type {?} */
+            var resolved = this.parameters.find((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return p.parameter === parameter; }));
+            return resolved ? resolved.resolvedValue : null;
+        };
+        /**
+         * @template T
+         * @param {?} parameter
+         * @param {?} value
+         * @return {?}
+         */
+        ResolvedParameters.prototype.replace = /**
+         * @template T
+         * @param {?} parameter
+         * @param {?} value
+         * @return {?}
+         */
+        function (parameter, value) {
+            return new ResolvedParameters(this.parameters.filter((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return p.parameter !== parameter; })).concat({
+                parameter: parameter,
+                resolvedValue: value
+            }));
+        };
+        /**
+         * @protected
+         * @return {?}
+         */
+        ResolvedParameters.prototype.getFormattedRouteId = /**
+         * @protected
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var routeIdParam = this.getRouteIdParam();
+            return routeIdParam ? routeIdParam.parameter.type.format(routeIdParam.resolvedValue) : null;
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        ResolvedParameters.prototype.getRouteIdParam = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            return this.parameters.find((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return p.parameter.isRouteId; }));
+        };
+        /**
+         * @protected
+         * @return {?}
+         */
+        ResolvedParameters.prototype.getFormattedParameters = /**
+         * @protected
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var params = {};
+            /** @type {?} */
+            var routeIdParam = this.parameters.filter((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return !p.parameter.isRouteId; })).forEach((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) {
+                params[p.parameter.name] = p.parameter.type.format(p.resolvedValue);
+            }));
+            return params;
+        };
+        /**
+         * @return {?}
+         */
+        ResolvedParameters.prototype.hasRouteId = /**
+         * @return {?}
+         */
+        function () {
+            return !!this.getRouteIdParam();
+        };
+        /**
+         * @param {?} previous
+         * @param {?} router
+         * @param {?} activatedRoute
+         * @return {?}
+         */
+        ResolvedParameters.prototype.redirect = /**
+         * @param {?} previous
+         * @param {?} router
+         * @param {?} activatedRoute
+         * @return {?}
+         */
+        function (previous, router, activatedRoute) {
+            /** @type {?} */
+            var routeId = this.getFormattedRouteId();
+            /** @type {?} */
+            var relativePath = !!previous.hasRouteId() ? '..' : '.';
+            /** @type {?} */
+            var path = routeId ? [relativePath, routeId, this.getFormattedParameters()] : [relativePath, this.getFormattedParameters()];
+            router.navigate(path, {
+                relativeTo: activatedRoute,
+            });
+        };
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], ResolvedParameters.prototype, "getFormattedRouteId", null);
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], ResolvedParameters.prototype, "getFormattedParameters", null);
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [ResolvedParameters, router.Router, router.ActivatedRoute]),
+            __metadata("design:returntype", void 0)
+        ], ResolvedParameters.prototype, "redirect", null);
+        return ResolvedParameters;
+    }());
+    if (false) {
+        /** @type {?} */
+        ResolvedParameters.prototype.parameters;
+    }
+    exports.RouteParameterBindings = /** @class */ (function (_super) {
+        __extends(RouteParameterBindings, _super);
+        function RouteParameterBindings(component, router, activatedRoute) {
+            var _this = _super.call(this) || this;
+            _this.component = component;
+            _this.router = router;
+            _this.activatedRoute = activatedRoute;
+            _this._incomingRouteChange = new pectin.MutableValueModel(false);
+            _this.resolvedParameters = new pectin.MutableValueModel();
+            var _a = pectin.Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe;
+            _this.txo = new pectin.TransactionObserver(); //.onEvent(e => console.log(e.toString()));
+            //.onEvent(e => console.log(e.toString()));
+            /** @type {?} */
+            var routeParameterDefs = typescriptUtilities.Klass.get(component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
+            routeParameterDefs.forEach((/**
+             * @param {?} parameter
+             * @return {?}
+             */
+            function (parameter) { return _this.installBinding(parameter); }));
+            /** @type {?} */
+            var incomingResolvedRouteParameters = observe.valuesFrom(activatedRoute.paramMap)
+                .last()
+                .map((/**
+             * @param {?} params
+             * @return {?}
+             */
+            function (params) {
+                /** @type {?} */
+                var result = [];
+                routeParameterDefs.forEach((/**
+                 * @param {?} parameter
+                 * @return {?}
+                 */
+                function (parameter) {
+                    result.push({ parameter: parameter, resolvedValue: parameter.type.parse(params.get(parameter.name)) });
+                }));
+                return new ResolvedParameters(result);
+            }));
+            incomingResolvedRouteParameters.subscribe((/**
+             * @param {?} resolvedParameters
+             * @return {?}
+             */
+            function (resolvedParameters) {
+                _this._incomingRouteChange.value = true;
+                _this.resolvedParameters.value = resolvedParameters;
+                _this._incomingRouteChange.value = false;
+            }));
+            when.valueOf(_this.resolvedParameters).changes((/**
+             * @param {?} params
+             * @param {?} previous
+             * @return {?}
+             */
+            function (params, previous) {
+                params.redirect(previous, router, activatedRoute);
+            }), { unless: _this.incomingRouteChange });
+            _this.txo.observe('incomingResolvedRouteParameters', incomingResolvedRouteParameters);
+            _this.txo.observe('this.routeIsChanging', _this.incomingRouteChange);
+            return _this;
+        }
+        Object.defineProperty(RouteParameterBindings.prototype, "incomingRouteChange", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._incomingRouteChange.readonly;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @protected
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        RouteParameterBindings.prototype.installBinding = /**
+         * @protected
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        function (parameter) {
+            /** @type {?} */
+            var model = this.getModelFor(parameter);
+            this.txo.observe(parameter.propertyName, model);
+            this.registerDisposable(new pectin.Binding(this.resolvedParameters, model, {
+                toRight: /**
+                 * @param {?} parameters
+                 * @return {?}
+                 */
+                function (parameters) {
+                    return parameters.get(parameter);
+                },
+                toLeft: /**
+                 * @param {?} value
+                 * @param {?=} currentParameters
+                 * @return {?}
+                 */
+                function (value, currentParameters) {
+                    return currentParameters.replace(parameter, value);
+                }
+            }));
+        };
+        /**
+         * @private
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        RouteParameterBindings.prototype.getModelFor = /**
+         * @private
+         * @template T
+         * @param {?} parameter
+         * @return {?}
+         */
+        function (parameter) {
+            return this.component[parameter.propertyName];
+        };
+        return RouteParameterBindings;
+    }(pectin.GarbageCollector));
+    if (false) {
+        /** @type {?} */
+        exports.RouteParameterBindings.prototype._incomingRouteChange;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.RouteParameterBindings.prototype.txo;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.RouteParameterBindings.prototype.resolvedParameters;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.RouteParameterBindings.prototype.component;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.RouteParameterBindings.prototype.router;
+        /**
+         * @type {?}
+         * @private
+         */
+        exports.RouteParameterBindings.prototype.activatedRoute;
+    }
+    (function (RouteParameterBindings) {
+        RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
+    })(exports.RouteParameterBindings || (exports.RouteParameterBindings = {}));
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var AbstractPlaceComponent = /** @class */ (function (_super) {
+        __extends(AbstractPlaceComponent, _super);
+        function AbstractPlaceComponent(activatedRoute, router) {
+            var _this = _super.call(this) || this;
+            _this.activatedRoute = activatedRoute;
+            _this.routeBindingMediator = _this.registerDisposable(new exports.RouteParameterBindings(_this, router, activatedRoute));
+            // See https://coolon.atlassian.net/browse/PEC-59
+            ((/** @type {?} */ ((/** @type {?} */ (_this.titleModel))))).setDefault(_this.placeConfig.title);
+            return _this;
+        }
+        Object.defineProperty(AbstractPlaceComponent.prototype, "placeConfig", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return Place.getDescriptor((/** @type {?} */ ((/** @type {?} */ (this.constructor)))));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @return {?}
+         */
+        AbstractPlaceComponent.prototype.canDeactivate = /**
+         * @return {?}
+         */
+        function () {
+            return true;
+        };
+        __decorate([
+            pectin.UseDelegate(),
+            __metadata("design:type", pectin.MutableValueModel)
+        ], AbstractPlaceComponent.prototype, "titleModel", void 0);
+        __decorate([
+            fastMemoizeDecorator.Memoize(),
+            __metadata("design:type", Place.Descriptor),
+            __metadata("design:paramtypes", [])
+        ], AbstractPlaceComponent.prototype, "placeConfig", null);
+        return AbstractPlaceComponent;
+    }(DisposableComponent));
+    if (false) {
+        /** @type {?} */
+        AbstractPlaceComponent.prototype.titleModel;
+        /**
+         * @type {?}
+         * @private
+         */
+        AbstractPlaceComponent.prototype.routeBindingMediator;
+        /**
+         * @type {?}
+         * @protected
+         */
+        AbstractPlaceComponent.prototype.activatedRoute;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     */
+    function PlaceComponent() { }
+    if (false) {
+        /** @type {?} */
+        PlaceComponent.prototype.titleModel;
+        /**
+         * @return {?}
+         */
+        PlaceComponent.prototype.canDeactivate = function () { };
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var BusyOverlayComponent = /** @class */ (function () {
+        function BusyOverlayComponent() {
+        }
+        /**
+         * @return {?}
+         */
+        BusyOverlayComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        BusyOverlayComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'aup-busy-overlay',
+                        template: "<ng-content></ng-content>\n<div class=\"busy-overlay-backdrop\" *ngIf=\"busyModel.value\">\n  <mat-progress-spinner mode=\"indeterminate\" [diameter]=\"52\"></mat-progress-spinner>\n</div>\n",
+                        styles: [":host{position:relative}div.busy-overlay-backdrop{position:absolute;background-color:rgba(0,0,0,.2);top:0;left:0;bottom:0;right:0;display:-ms-grid;display:grid;-ms-grid-columns:auto;grid-template-columns:auto;-ms-grid-rows:auto;grid-template-rows:auto;place-content:center}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        BusyOverlayComponent.ctorParameters = function () { return []; };
+        BusyOverlayComponent.propDecorators = {
+            busyModel: [{ type: core.Input }],
+            busy: [{ type: core.Input }]
+        };
+        __decorate([
+            pectin.UseDelegatingValueModel(),
+            __metadata("design:type", pectin.ValueModel)
+        ], BusyOverlayComponent.prototype, "busyModel", void 0);
+        __decorate([
+            pectin.StoreInValueModel('busyModel'),
+            __metadata("design:type", Boolean)
+        ], BusyOverlayComponent.prototype, "busy", void 0);
+        return BusyOverlayComponent;
+    }());
+    if (false) {
+        /** @type {?} */
+        BusyOverlayComponent.prototype.busyModel;
+        /** @type {?} */
+        BusyOverlayComponent.prototype.busy;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var EmptyStateComponent = /** @class */ (function () {
+        function EmptyStateComponent() {
+        }
+        /**
+         * @return {?}
+         */
+        EmptyStateComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        EmptyStateComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-empty-state',
+                        template: "\n      <div class=\"container\">\n          <ng-content></ng-content>\n      </div>\n  ",
+                        styles: [":host{display:flex;flex-direction:column;justify-content:center;align-items:center}.container{padding:var(--default-padding);border:2px dashed rgba(0,0,0,.2);border-radius:5px;font-size:14px;font-weight:300}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        EmptyStateComponent.ctorParameters = function () { return []; };
+        return EmptyStateComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PlaceService = /** @class */ (function () {
+        function PlaceService() {
+            this._activePlaces = new pectin.MutableListModel();
+        }
+        Object.defineProperty(PlaceService.prototype, "activePlaces", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this._activePlaces.readonly;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @param {?} place
+         * @return {?}
+         */
+        PlaceService.prototype.onActivate = /**
+         * @param {?} place
+         * @return {?}
+         */
+        function (place) {
+            this._activePlaces.push(place);
+        };
+        /**
+         * @param {?} place
+         * @return {?}
+         */
+        PlaceService.prototype.onDeactivate = /**
+         * @param {?} place
+         * @return {?}
+         */
+        function (place) {
+            this._activePlaces.remove(place);
+        };
+        PlaceService.decorators = [
+            { type: core.Injectable, args: [{
+                        providedIn: 'root'
+                    },] }
+        ];
+        /** @nocollapse */
+        PlaceService.ctorParameters = function () { return []; };
+        /** @nocollapse */ PlaceService.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceService_Factory() { return new PlaceService(); }, token: PlaceService, providedIn: "root" });
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], PlaceService.prototype, "onActivate", null);
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", void 0)
+        ], PlaceService.prototype, "onDeactivate", null);
+        return PlaceService;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceService.prototype._activePlaces;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PlaceOutletComponent = /** @class */ (function () {
+        function PlaceOutletComponent(placeService) {
+            this.placeService = placeService;
+        }
+        /**
+         * @return {?}
+         */
+        PlaceOutletComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+        function () {
+        };
+        /**
+         * @param {?} $event
+         * @return {?}
+         */
+        PlaceOutletComponent.prototype.onActivate = /**
+         * @param {?} $event
+         * @return {?}
+         */
+        function ($event) {
+            this.placeService.onActivate($event);
+        };
+        /**
+         * @param {?} $event
+         * @return {?}
+         */
+        PlaceOutletComponent.prototype.onDeactivate = /**
+         * @param {?} $event
+         * @return {?}
+         */
+        function ($event) {
+            this.placeService.onDeactivate($event);
+        };
+        PlaceOutletComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'angular-ui-powerups-place-outlet',
+                        template: "<router-outlet (activate)=\"onActivate($event)\" (deactivate)=\"onDeactivate($event)\"></router-outlet>\n",
+                        styles: [":host{grid-area:main;display:-ms-grid;display:grid;-ms-grid-rows:0 1fr;grid-template-rows:0 1fr;min-height:0}"]
+                    }] }
+        ];
+        /** @nocollapse */
+        PlaceOutletComponent.ctorParameters = function () { return [
+            { type: PlaceService }
+        ]; };
+        return PlaceOutletComponent;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceOutletComponent.prototype.placeService;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PlaceModule = /** @class */ (function () {
+        function PlaceModule() {
+        }
+        PlaceModule.decorators = [
+            { type: core.NgModule, args: [{
+                        imports: [
+                            common.CommonModule,
+                            material.MatProgressSpinnerModule,
+                            router.RouterModule
+                        ],
+                        declarations: [
+                            EmptyStateComponent,
+                            BusyOverlayComponent,
+                            PlaceOutletComponent
+                        ],
+                        entryComponents: [BusyOverlayComponent],
+                        exports: [
+                            BusyOverlayComponent,
+                            PlaceOutletComponent,
+                            EmptyStateComponent
+                        ],
+                        providers: [
+                            PlaceService
+                        ]
+                    },] }
+        ];
+        return PlaceModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var LeavePlaceGuard = /** @class */ (function () {
+        function LeavePlaceGuard(router, injector) {
+            this.router = router;
+            this.injector = injector;
+        }
+        /**
+         * @param {?} component
+         * @param {?} currentRoute
+         * @param {?} currentState
+         * @param {?=} nextState
+         * @return {?}
+         */
+        LeavePlaceGuard.prototype.canDeactivate = /**
+         * @param {?} component
+         * @param {?} currentRoute
+         * @param {?} currentState
+         * @param {?=} nextState
+         * @return {?}
+         */
+        function (component, currentRoute, currentState, nextState) {
+            return component.canDeactivate();
+        };
+        LeavePlaceGuard.decorators = [
+            { type: core.Injectable, args: [{
+                        providedIn: 'root'
+                    },] }
+        ];
+        /** @nocollapse */
+        LeavePlaceGuard.ctorParameters = function () { return [
+            { type: router.Router },
+            { type: core.Injector }
+        ]; };
+        /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(core.ɵɵinject(router.Router), core.ɵɵinject(core.INJECTOR)); }, token: LeavePlaceGuard, providedIn: "root" });
+        return LeavePlaceGuard;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        LeavePlaceGuard.prototype.router;
+        /**
+         * @type {?}
+         * @private
+         */
+        LeavePlaceGuard.prototype.injector;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var RouteParameterSanitiser = /** @class */ (function () {
+        function RouteParameterSanitiser(parameterDefs, injector) {
+            this.parameterDefs = parameterDefs;
+            this.injector = injector;
+            this.sanitisedParameters = [];
+            this.routeParameter = parameterDefs.find((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return p.isRouteId; }));
+            this.queryParameters = parameterDefs.filter((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) { return !p.isRouteId; }));
+        }
+        /**
+         * @param {?} snapshot
+         * @return {?}
+         */
+        RouteParameterSanitiser.prototype.sanitise = /**
+         * @param {?} snapshot
+         * @return {?}
+         */
+        function (snapshot) {
+            return __awaiter(this, void 0, void 0, function () {
+                var e_1, _a, routeOk, _b, _c, param, e_1_1;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!this.routeParameter) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.sanitiseParameter(this.routeParameter, snapshot.paramMap.get(this.routeParameter.name))];
+                        case 1:
+                            routeOk = _d.sent();
+                            if (!routeOk) {
+                                // if the route id isn't ok we redirect immediately as the query params may need to be sanitised in the
+                                // context of the route id.
+                                return [2 /*return*/, false];
+                            }
+                            _d.label = 2;
+                        case 2:
+                            _d.trys.push([2, 7, 8, 9]);
+                            _b = __values(this.queryParameters), _c = _b.next();
+                            _d.label = 3;
+                        case 3:
+                            if (!!_c.done) return [3 /*break*/, 6];
+                            param = _c.value;
+                            return [4 /*yield*/, this.sanitiseParameter(param, snapshot.queryParamMap.get(param.name))];
+                        case 4:
+                            _d.sent();
+                            _d.label = 5;
+                        case 5:
+                            _c = _b.next();
+                            return [3 /*break*/, 3];
+                        case 6: return [3 /*break*/, 9];
+                        case 7:
+                            e_1_1 = _d.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 9];
+                        case 8:
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 9: return [2 /*return*/, this.sanitisedParameters.length === 0];
+                    }
+                });
+            });
+        };
+        /**
+         * @template T
+         * @param {?} def
+         * @param {?} formattedInitialValue
+         * @return {?}
+         */
+        RouteParameterSanitiser.prototype.sanitiseParameter = /**
+         * @template T
+         * @param {?} def
+         * @param {?} formattedInitialValue
+         * @return {?}
+         */
+        function (def, formattedInitialValue) {
+            return __awaiter(this, void 0, void 0, function () {
+                var sanitiser, initialValue, sanitisedValue;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!def) return [3 /*break*/, 2];
+                            sanitiser = this.getSanitiser(def);
+                            if (!sanitiser) return [3 /*break*/, 2];
+                            initialValue = def.type.parse(formattedInitialValue);
+                            return [4 /*yield*/, sanitiser.sanitise(initialValue)];
+                        case 1:
+                            sanitisedValue = _a.sent();
+                            if (initialValue !== sanitisedValue) {
+                                this.sanitisedParameters.push({ def: def, value: def.type.format(sanitisedValue) });
+                                return [2 /*return*/, false];
+                            }
+                            _a.label = 2;
+                        case 2: return [2 /*return*/, true];
+                    }
+                });
+            });
+        };
+        /**
+         * @param {?} router
+         * @return {?}
+         */
+        RouteParameterSanitiser.prototype.redirect = /**
+         * @param {?} router
+         * @return {?}
+         */
+        function (router) {
+            var _this = this;
+            pectin.assert.isTruthy(this.sanitisedParameters.length !== 0);
+            /** @type {?} */
+            var sanitisedRouteId = this.sanitisedParameters.find((/**
+             * @param {?} s
+             * @return {?}
+             */
+            function (s) { return s.def === _this.routeParameter; }));
+            if (sanitisedRouteId) {
+                return router.navigate(['..', sanitisedRouteId.value]);
+            }
+            else {
+                /** @type {?} */
+                var queryParams = this.sanitisedParameters.filter((/**
+                 * @param {?} s
+                 * @return {?}
+                 */
+                function (s) { return s.def !== _this.routeParameter; }))
+                    .reduce((/**
+                 * @param {?} params
+                 * @param {?} item
+                 * @return {?}
+                 */
+                function (params, item) {
+                    var _a;
+                    return (__assign({}, params, (_a = {}, _a[item.def.name] = item.value, _a)));
+                }), {});
+                return router.navigate(['.', queryParams]);
+            }
+        };
+        /**
+         * @private
+         * @template T
+         * @param {?} def
+         * @return {?}
+         */
+        RouteParameterSanitiser.prototype.getSanitiser = /**
+         * @private
+         * @template T
+         * @param {?} def
+         * @return {?}
+         */
+        function (def) {
+            return def.sanitiser ? this.injector.get(def.sanitiser, new def.sanitiser()) : null;
+        };
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, String]),
+            __metadata("design:returntype", Promise)
+        ], RouteParameterSanitiser.prototype, "sanitiseParameter", null);
+        __decorate([
+            src.Memoize(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Object)
+        ], RouteParameterSanitiser.prototype, "getSanitiser", null);
+        return RouteParameterSanitiser;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        RouteParameterSanitiser.prototype.routeParameter;
+        /**
+         * @type {?}
+         * @private
+         */
+        RouteParameterSanitiser.prototype.queryParameters;
+        /**
+         * @type {?}
+         * @private
+         */
+        RouteParameterSanitiser.prototype.sanitisedParameters;
+        /** @type {?} */
+        RouteParameterSanitiser.prototype.parameterDefs;
+        /** @type {?} */
+        RouteParameterSanitiser.prototype.injector;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var PlaceRouteGuard = /** @class */ (function () {
+        function PlaceRouteGuard(router, injector) {
+            this.router = router;
+            this.injector = injector;
+        }
+        /**
+         * @param {?} route
+         * @param {?} state
+         * @return {?}
+         */
+        PlaceRouteGuard.prototype.canActivate = /**
+         * @param {?} route
+         * @param {?} state
+         * @return {?}
+         */
+        function (route, state) {
+            var _this = this;
+            /** @type {?} */
+            var routeParameters = typescriptUtilities.Klass.get(route.component).getMetadataList(exports.RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
+            /** @type {?} */
+            var sanitiser = new RouteParameterSanitiser(routeParameters, this.injector);
+            return sanitiser.sanitise(route).then((/**
+             * @param {?} proceed
+             * @return {?}
+             */
+            function (proceed) {
+                if (!proceed) {
+                    sanitiser.redirect(_this.router);
+                }
+                return proceed;
+            }));
+        };
+        PlaceRouteGuard.decorators = [
+            { type: core.Injectable, args: [{
+                        providedIn: 'root'
+                    },] }
+        ];
+        /** @nocollapse */
+        PlaceRouteGuard.ctorParameters = function () { return [
+            { type: router.Router },
+            { type: core.Injector }
+        ]; };
+        /** @nocollapse */ PlaceRouteGuard.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function PlaceRouteGuard_Factory() { return new PlaceRouteGuard(core.ɵɵinject(router.Router), core.ɵɵinject(core.INJECTOR)); }, token: PlaceRouteGuard, providedIn: "root" });
+        __decorate([
+            pectin.Trace(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [router.ActivatedRouteSnapshot, router.RouterStateSnapshot]),
+            __metadata("design:returntype", Object)
+        ], PlaceRouteGuard.prototype, "canActivate", null);
+        return PlaceRouteGuard;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceRouteGuard.prototype.router;
+        /**
+         * @type {?}
+         * @private
+         */
+        PlaceRouteGuard.prototype.injector;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     */
+    function JsonArray() { }
+    /**
+     * @record
+     */
+    function JsonMap() { }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template T
+     */
+    function ParameterOptions() { }
+    if (false) {
+        /** @type {?|undefined} */
+        ParameterOptions.prototype.as;
+        /** @type {?|undefined} */
+        ParameterOptions.prototype.sanitiser;
+    }
+    /**
+     * @template T
+     * @param {?} type
+     * @param {?=} options
+     * @return {?}
+     */
+    function RouteId(type, options) {
+        // assert.isTruthy(type.isValid());
+        return (/**
+         * @param {?} prototype
+         * @param {?} propertyKey
+         * @return {?}
+         */
+        function (prototype, propertyKey) {
+            /** @type {?} */
+            var param = createDefinition(propertyKey, type, options, true);
+            typescriptUtilities.Klass.get(prototype).addToOwnMetadataList(exports.RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+            pectin.UseDelegate()(prototype, propertyKey);
+        });
+    }
+    /**
+     * @template T
+     * @param {?} type
+     * @param {?=} options
+     * @return {?}
+     */
+    function QueryParameter(type, options) {
+        // assert.isTruthy(type.isValid());
+        return (/**
+         * @param {?} prototype
+         * @param {?} propertyKey
+         * @return {?}
+         */
+        function (prototype, propertyKey) {
+            /** @type {?} */
+            var param = createDefinition(propertyKey, type, options, false);
+            typescriptUtilities.Klass.get(prototype).addToOwnMetadataList(exports.RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+            pectin.UseDelegate()(prototype, propertyKey);
+        });
+    }
+    /**
+     * @template T
+     * @param {?} propertyName
+     * @param {?} type
+     * @param {?} options
+     * @param {?} routeId
+     * @return {?}
+     */
+    function createDefinition(propertyName, type, options, routeId) {
+        /** @type {?} */
+        var opts = typescriptUtilities.Opts.get(options);
+        /** @type {?} */
+        var propertyNameAsString = pectin.assert.notNil(propertyName).toString();
+        /** @type {?} */
+        var def = {
+            name: opts.getOptional('as', propertyNameAsString),
+            propertyName: propertyNameAsString,
+            type: pectin.assert.notNil(type),
+            sanitiser: opts.getOptional('sanitiser', null),
+            isRouteId: routeId
+        };
+        return def;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template T
+     */
+    function ParameterDefinition() { }
+    if (false) {
+        /** @type {?} */
+        ParameterDefinition.prototype.name;
+        /** @type {?} */
+        ParameterDefinition.prototype.propertyName;
+        /** @type {?} */
+        ParameterDefinition.prototype.type;
+        /** @type {?} */
+        ParameterDefinition.prototype.sanitiser;
+        /** @type {?} */
+        ParameterDefinition.prototype.isRouteId;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     * @template T
+     */
+    function ParameterSanitiser() { }
+    if (false) {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        ParameterSanitiser.prototype.sanitise = function (value) { };
+    }
+
+    /**
+     * @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
+
+    (function (ParameterType) {
+        var StringType = /** @class */ (function () {
+            function StringType() {
+            }
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            StringType.prototype.format = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return value;
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            StringType.prototype.parse = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return value;
+            };
+            return StringType;
+        }());
+        var NumberType = /** @class */ (function () {
+            function NumberType() {
+            }
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            NumberType.prototype.format = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return "" + value;
+            };
+            /**
+             * @param {?} value
+             * @return {?}
+             */
+            NumberType.prototype.parse = /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return +value;
+            };
+            return NumberType;
+        }());
+        ParameterType.STRING = new StringType();
+        ParameterType.NUMBER = new NumberType();
+    })(exports.ParameterType || (exports.ParameterType = {}));
+
+    exports.ACTIVITY_DATA = ACTIVITY_DATA;
+    exports.AbstractActivity = AbstractActivity;
+    exports.AbstractInputComponent = AbstractInputComponent;
+    exports.AbstractPlaceComponent = AbstractPlaceComponent;
+    exports.AlertDialogComponent = AlertDialogComponent;
+    exports.AngularUiPowerupsModule = AngularUiPowerupsModule;
+    exports.BusyOverlayComponent = BusyOverlayComponent;
+    exports.CommandDirective = CommandDirective;
+    exports.ConfirmationDialogComponent = ConfirmationDialogComponent;
+    exports.DialogInteractionService = DialogInteractionService;
+    exports.Dimension = Dimension;
+    exports.DisposableComponent = DisposableComponent;
+    exports.EmptyStateComponent = EmptyStateComponent;
+    exports.FocusBindingDirective = FocusBindingDirective;
+    exports.INTERACTION_CONTEXT = INTERACTION_CONTEXT;
+    exports.InteractionContext = InteractionContext;
+    exports.InteractionModule = InteractionModule;
+    exports.LeavePlaceGuard = LeavePlaceGuard;
+    exports.NumberInputComponent = NumberInputComponent;
+    exports.PasswordInputComponent = PasswordInputComponent;
+    exports.Place = Place;
+    exports.PlaceModule = PlaceModule;
+    exports.PlaceOutletComponent = PlaceOutletComponent;
+    exports.PlaceRouteGuard = PlaceRouteGuard;
+    exports.PlaceService = PlaceService;
+    exports.Point = Point;
+    exports.QueryParameter = QueryParameter;
+    exports.ResizeAwareComponent = ResizeAwareComponent;
+    exports.RouteId = RouteId;
+    exports.RouteParameterSanitiser = RouteParameterSanitiser;
+    exports.SelectInputComponent = SelectInputComponent;
+    exports.StringInputComponent = StringInputComponent;
+    exports.ɵa = CommandDirective;
+    exports.ɵb = FocusBindingDirective;
+    exports.ɵc = DisposableComponent;
+    exports.ɵd = NumberInputComponent;
+    exports.ɵe = AbstractInputComponent;
+    exports.ɵf = StringInputComponent;
+    exports.ɵg = PasswordInputComponent;
+    exports.ɵh = SelectInputComponent;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=coolon-angular-ui-powerups.umd.js.map