@coolon/angular-ui-powerups 0.0.1

package/fesm5/coolon-angular-ui-powerups.js

@@ -0,0 +1,3164 @@
+import { DOCUMENT, CommonModule } from '@angular/common';
+import { EventEmitter, Input, Output, HostListener, Component, Directive, ElementRef, Inject, NgZone, NgModule, InjectionToken, ViewChild, Injector, ComponentFactoryResolver, ViewContainerRef, Injectable, ɵɵdefineInjectable, ɵɵinject, INJECTOR } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatInputModule, MatFormFieldModule, MatSelectModule, MatDialog, MatButtonModule, MatDialogModule, MatTabsModule, MatProgressSpinnerModule } from '@angular/material';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { __extends, __decorate, __metadata, __assign, __awaiter, __generator, __values } from 'tslib';
+import { GarbageCollector, MutableListModel, Constant, UseDelegate, MutableValueModel, assert, Dsl, Logger, ListModel, StoreInListModel, ValueHolder, EventListenerList, DelegatingValueModel, lang, Trace, TransactionObserver, Binding, UseDelegatingValueModel, ValueModel, StoreInValueModel } from '@coolon/pectin';
+import ResizeObserver from 'resize-observer-polyfill';
+import { PortalModule } from '@angular/cdk/portal';
+import { Deferred } from '@coolon/pectin/lib/promise/deferred.class';
+import { MatDialog as MatDialog$1 } from '@angular/material/dialog';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator';
+import { isNil } from 'lodash';
+import 'reflect-metadata';
+import { Router, ActivatedRoute, RouterModule, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { Klass, Opts } from '@coolon/typescript-utilities';
+import { Memoize as Memoize$1 } from '@typescript-plus/fast-memoize-decorator/dist/src';
+
+/**
+ * @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;
+}(GarbageCollector));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+var EMPTY_ERRORS = new MutableListModel().readonly;
+/**
+ * @abstract
+ * @template T
+ */
+var AbstractInputComponent = /** @class */ (function (_super) {
+    __extends(AbstractInputComponent, _super);
+    function AbstractInputComponent() {
+        var _this = _super.call(this) || this;
+        _this.focus = new EventEmitter();
+        _this.blur = new EventEmitter();
+        _this.enterKey = new EventEmitter();
+        _this.escapeKey = new 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 || 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: Input }],
+        label: [{ type: Input }],
+        floatLabel: [{ type: Input }],
+        hint: [{ type: Input }],
+        placeholder: [{ type: Input }],
+        focusCommand: [{ type: Input, args: ['command.focus',] }],
+        blurCommand: [{ type: Input, args: ['command.blur',] }],
+        enterCommand: [{ type: Input, args: ['command.enter',] }],
+        escapeCommand: [{ type: Input, args: ['command.escape',] }],
+        clickCommand: [{ type: Input, args: ['command.click',] }],
+        focus: [{ type: Output }],
+        blur: [{ type: Output }],
+        enterKey: [{ type: Output }],
+        escapeKey: [{ type: Output }],
+        notifyClick: [{ type: HostListener, args: ['click',] }],
+        notifyFocusIn: [{ type: HostListener, args: ['focusin',] }],
+        notifyFocusOut: [{ type: HostListener, args: ['focusout',] }]
+    };
+    __decorate([
+        UseDelegate(),
+        __metadata("design:type", 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: 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 () {
+        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 = 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: Directive, args: [{
+                    // tslint:disable-next-line:directive-selector
+                    selector: '[pectinCommand]'
+                },] }
+    ];
+    /** @nocollapse */
+    CommandDirective.ctorParameters = function () { return [
+        { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] }
+    ]; };
+    CommandDirective.propDecorators = {
+        pectinCommand: [{ type: Input }],
+        notifyClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+    };
+    return CommandDirective;
+}(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 = 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()) {
+                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 {
+                    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: Directive, args: [{
+                    // tslint:disable-next-line:directive-selector
+                    selector: '[pectinFocusBinding]'
+                },] }
+    ];
+    /** @nocollapse */
+    FocusBindingDirective.ctorParameters = function () { return [
+        { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
+        { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
+        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+    ]; };
+    FocusBindingDirective.propDecorators = {
+        pectinFocusBinding: [{ type: Input }],
+        focusBindingTarget: [{ type: Input }],
+        onFocusIn: [{ type: HostListener, args: ['focusin',] }],
+        onFocusOut: [{ type: 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: 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: 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: 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: Input }],
+        options: [{ type: Input }],
+        optionLabel: [{ type: Input }],
+        optionLabelFormat: [{ type: Input }]
+    };
+    __decorate([
+        UseDelegate(),
+        __metadata("design:type", ListModel)
+    ], SelectInputComponent.prototype, "optionsModel", void 0);
+    __decorate([
+        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: NgModule, args: [{
+                    declarations: [
+                        CommandDirective,
+                        FocusBindingDirective,
+                        NumberInputComponent,
+                        StringInputComponent,
+                        PasswordInputComponent,
+                        SelectInputComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        BrowserModule,
+                        BrowserAnimationsModule,
+                        FormsModule,
+                        MatInputModule,
+                        MatFormFieldModule,
+                        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
+ */
+var 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 {?} */
+    Bounds.prototype.top;
+    /** @type {?} */
+    Bounds.prototype.left;
+    /** @type {?} */
+    Bounds.prototype.width;
+    /** @type {?} */
+    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;
+})(Bounds || (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 ValueHolder(new 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 = 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 EventListenerList();
+        _this._cancelListeners = new EventListenerList();
+        _this._finishListeners = new EventListenerList();
+        _this._busyModel = new 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 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 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: 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: 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;
+        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: 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: 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
+ */
+var ActivityContainerComponent = /** @class */ (function (_super) {
+    __extends(ActivityContainerComponent, _super);
+    function ActivityContainerComponent() {
+        var _this = _super.call(this) || this;
+        _this.activityTabs = new MutableListModel();
+        _this.obsoleteTabs = [];
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+    };
+    /**
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.ngAfterViewInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        var observe = 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.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: 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: Input }],
+        initialActivity: [{ type: Input }],
+        tabs: [{ type: ViewChild, args: ['tabs', { static: true },] }]
+    };
+    return ActivityContainerComponent;
+}(DisposableComponent));
+if (false) {
+    /** @type {?} */
+    ActivityContainerComponent.prototype.parentInteractionContext;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.initialActivity;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.tabs;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.activityTabs;
+    /**
+     * @type {?}
+     * @private
+     */
+    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;
+    }
+})(ActivityContainerComponent || (ActivityContainerComponent = {}));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @template D, R, E
+ */
+var 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 = 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: Component, args: [{
+                    selector: 'angular-ui-powerups-activity-outlet',
+                    template: '',
+                    styles: [":host{display:block}"]
+                }] }
+    ];
+    /** @nocollapse */
+    ActivityOutletComponent.ctorParameters = function () { return [
+        { type: ComponentFactoryResolver },
+        { type: ViewContainerRef },
+        { type: Injector }
+    ]; };
+    ActivityOutletComponent.propDecorators = {
+        interactionContext: [{ type: Input }],
+        activityContext: [{ type: Input }]
+    };
+    return ActivityOutletComponent;
+}());
+if (false) {
+    /** @type {?} */
+    ActivityOutletComponent.prototype.interactionContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.activityComponent;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.componentFactoryResolver;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityOutletComponent.prototype.viewContainerRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    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 lang.notImplemented();
+        };
+        /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        OutletInteractionContext.prototype.confirm = /**
+         * @param {?} confirm
+         * @return {?}
+         */
+        function (confirm) {
+            return 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 lang.notImplemented();
+        };
+        return OutletInteractionContext;
+    }());
+    ActivityOutletComponent.OutletInteractionContext = OutletInteractionContext;
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        OutletInteractionContext.prototype.context;
+    }
+})(ActivityOutletComponent || (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(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: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    DialogInteractionService.ctorParameters = function () { return [
+        { type: MatDialog }
+    ]; };
+    /** @nocollapse */ DialogInteractionService.ngInjectableDef = ɵɵdefineInjectable({ factory: function DialogInteractionService_Factory() { return new DialogInteractionService(ɵɵinject(MatDialog$1)); }, 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: NgModule, args: [{
+                    imports: [
+                        CommonModule,
+                        MatButtonModule,
+                        MatDialogModule,
+                        MatTabsModule,
+                        PortalModule
+                    ],
+                    declarations: [
+                        ActivityContainerComponent,
+                        ConfirmationDialogComponent,
+                        AlertDialogComponent,
+                        ActivityOutletComponent
+                    ],
+                    entryComponents: [
+                        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) {
+            assert.notNil(options);
+            this.path = options.path;
+            this.title = options.title;
+            this.authenticate = 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([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], ResolvedParameters.prototype, "getFormattedRouteId", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], ResolvedParameters.prototype, "getFormattedParameters", null);
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [ResolvedParameters, Router, ActivatedRoute]),
+        __metadata("design:returntype", void 0)
+    ], ResolvedParameters.prototype, "redirect", null);
+    return ResolvedParameters;
+}());
+if (false) {
+    /** @type {?} */
+    ResolvedParameters.prototype.parameters;
+}
+var 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 MutableValueModel(false);
+        _this.resolvedParameters = new MutableValueModel();
+        var _a = Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe;
+        _this.txo = new TransactionObserver(); //.onEvent(e => console.log(e.toString()));
+        //.onEvent(e => console.log(e.toString()));
+        /** @type {?} */
+        var routeParameterDefs = 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 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;
+}(GarbageCollector));
+if (false) {
+    /** @type {?} */
+    RouteParameterBindings.prototype._incomingRouteChange;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.txo;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.resolvedParameters;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.component;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    RouteParameterBindings.prototype.activatedRoute;
+}
+(function (RouteParameterBindings) {
+    RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
+})(RouteParameterBindings || (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 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([
+        UseDelegate(),
+        __metadata("design:type", MutableValueModel)
+    ], AbstractPlaceComponent.prototype, "titleModel", void 0);
+    __decorate([
+        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: 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: Input }],
+        busy: [{ type: Input }]
+    };
+    __decorate([
+        UseDelegatingValueModel(),
+        __metadata("design:type", ValueModel)
+    ], BusyOverlayComponent.prototype, "busyModel", void 0);
+    __decorate([
+        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: 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 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: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    PlaceService.ctorParameters = function () { return []; };
+    /** @nocollapse */ PlaceService.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceService_Factory() { return new PlaceService(); }, token: PlaceService, providedIn: "root" });
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PlaceService.prototype, "onActivate", null);
+    __decorate([
+        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: 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: NgModule, args: [{
+                    imports: [
+                        CommonModule,
+                        MatProgressSpinnerModule,
+                        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: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    LeavePlaceGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ LeavePlaceGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function LeavePlaceGuard_Factory() { return new LeavePlaceGuard(ɵɵinject(Router), ɵɵinject(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;
+        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([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, String]),
+        __metadata("design:returntype", Promise)
+    ], RouteParameterSanitiser.prototype, "sanitiseParameter", null);
+    __decorate([
+        Memoize$1(),
+        __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 = Klass.get(route.component).getMetadataList(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: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    PlaceRouteGuard.ctorParameters = function () { return [
+        { type: Router },
+        { type: Injector }
+    ]; };
+    /** @nocollapse */ PlaceRouteGuard.ngInjectableDef = ɵɵdefineInjectable({ factory: function PlaceRouteGuard_Factory() { return new PlaceRouteGuard(ɵɵinject(Router), ɵɵinject(INJECTOR)); }, token: PlaceRouteGuard, providedIn: "root" });
+    __decorate([
+        Trace(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [ActivatedRouteSnapshot, 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);
+        Klass.get(prototype).addToOwnMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+        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);
+        Klass.get(prototype).addToOwnMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY, param);
+        UseDelegate()(prototype, propertyKey);
+    });
+}
+/**
+ * @template T
+ * @param {?} propertyName
+ * @param {?} type
+ * @param {?} options
+ * @param {?} routeId
+ * @return {?}
+ */
+function createDefinition(propertyName, type, options, routeId) {
+    /** @type {?} */
+    var opts = Opts.get(options);
+    /** @type {?} */
+    var propertyNameAsString = assert.notNil(propertyName).toString();
+    /** @type {?} */
+    var def = {
+        name: opts.getOptional('as', propertyNameAsString),
+        propertyName: propertyNameAsString,
+        type: 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
+var ParameterType;
+(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();
+})(ParameterType || (ParameterType = {}));
+
+/**
+ * @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
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { ACTIVITY_DATA, AbstractActivity, AbstractInputComponent, AbstractPlaceComponent, ActivityContainerComponent, ActivityOutletComponent, AlertDialogComponent, AngularUiPowerupsModule, Bounds, BusyOverlayComponent, CommandDirective, ConfirmationDialogComponent, DialogInteractionService, Dimension, DisposableComponent, EmptyStateComponent, FocusBindingDirective, INTERACTION_CONTEXT, InteractionContext, InteractionModule, LeavePlaceGuard, NumberInputComponent, ParameterType, PasswordInputComponent, Place, PlaceModule, PlaceOutletComponent, PlaceRouteGuard, PlaceService, Point, QueryParameter, ResizeAwareComponent, RouteId, RouteParameterBindings, RouteParameterSanitiser, SelectInputComponent, StringInputComponent, CommandDirective as ɵa, FocusBindingDirective as ɵb, DisposableComponent as ɵc, NumberInputComponent as ɵd, AbstractInputComponent as ɵe, StringInputComponent as ɵf, PasswordInputComponent as ɵg, SelectInputComponent as ɵh };
+//# sourceMappingURL=coolon-angular-ui-powerups.js.map