@xplortech/apollo-angular 2.11.0

package/dist/directives/proxies.js

@@ -0,0 +1,1951 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Output, NgZone } from '@angular/core';
+import { ProxyCmp } from './angular-component-lib/utils';
+import { defineCustomElement as defineXplAccordion } from '@xplortech/apollo-core/components/xpl-accordion.js';
+import { defineCustomElement as defineXplApplicationShell } from '@xplortech/apollo-core/components/xpl-application-shell.js';
+import { defineCustomElement as defineXplAvatar } from '@xplortech/apollo-core/components/xpl-avatar.js';
+import { defineCustomElement as defineXplBackdrop } from '@xplortech/apollo-core/components/xpl-backdrop.js';
+import { defineCustomElement as defineXplBadge } from '@xplortech/apollo-core/components/xpl-badge.js';
+import { defineCustomElement as defineXplBanner } from '@xplortech/apollo-core/components/xpl-banner.js';
+import { defineCustomElement as defineXplBreadcrumbItem } from '@xplortech/apollo-core/components/xpl-breadcrumb-item.js';
+import { defineCustomElement as defineXplBreadcrumbs } from '@xplortech/apollo-core/components/xpl-breadcrumbs.js';
+import { defineCustomElement as defineXplButton } from '@xplortech/apollo-core/components/xpl-button.js';
+import { defineCustomElement as defineXplButtonRow } from '@xplortech/apollo-core/components/xpl-button-row.js';
+import { defineCustomElement as defineXplCalendar } from '@xplortech/apollo-core/components/xpl-calendar.js';
+import { defineCustomElement as defineXplCheckbox } from '@xplortech/apollo-core/components/xpl-checkbox.js';
+import { defineCustomElement as defineXplChoicelist } from '@xplortech/apollo-core/components/xpl-choicelist.js';
+import { defineCustomElement as defineXplContentArea } from '@xplortech/apollo-core/components/xpl-content-area.js';
+import { defineCustomElement as defineXplDashboard } from '@xplortech/apollo-core/components/xpl-dashboard.js';
+import { defineCustomElement as defineXplDataCard } from '@xplortech/apollo-core/components/xpl-data-card.js';
+import { defineCustomElement as defineXplDivider } from '@xplortech/apollo-core/components/xpl-divider.js';
+import { defineCustomElement as defineXplDropdown } from '@xplortech/apollo-core/components/xpl-dropdown.js';
+import { defineCustomElement as defineXplDropdownGroup } from '@xplortech/apollo-core/components/xpl-dropdown-group.js';
+import { defineCustomElement as defineXplDropdownHeading } from '@xplortech/apollo-core/components/xpl-dropdown-heading.js';
+import { defineCustomElement as defineXplDropdownOption } from '@xplortech/apollo-core/components/xpl-dropdown-option.js';
+import { defineCustomElement as defineXplDynamicTable } from '@xplortech/apollo-core/components/xpl-dynamic-table.js';
+import { defineCustomElement as defineXplDynamicTableCell } from '@xplortech/apollo-core/components/xpl-dynamic-table-cell.js';
+import { defineCustomElement as defineXplDynamicTableRow } from '@xplortech/apollo-core/components/xpl-dynamic-table-row.js';
+import { defineCustomElement as defineXplGrid } from '@xplortech/apollo-core/components/xpl-grid.js';
+import { defineCustomElement as defineXplGridItem } from '@xplortech/apollo-core/components/xpl-grid-item.js';
+import { defineCustomElement as defineXplHeaderAccordion } from '@xplortech/apollo-core/components/xpl-header-accordion.js';
+import { defineCustomElement as defineXplIcon } from '@xplortech/apollo-core/components/xpl-icon.js';
+import { defineCustomElement as defineXplInput } from '@xplortech/apollo-core/components/xpl-input.js';
+import { defineCustomElement as defineXplInputColor } from '@xplortech/apollo-core/components/xpl-input-color.js';
+import { defineCustomElement as defineXplInputDate } from '@xplortech/apollo-core/components/xpl-input-date.js';
+import { defineCustomElement as defineXplInputFile } from '@xplortech/apollo-core/components/xpl-input-file.js';
+import { defineCustomElement as defineXplInputPhone } from '@xplortech/apollo-core/components/xpl-input-phone.js';
+import { defineCustomElement as defineXplInputSearch } from '@xplortech/apollo-core/components/xpl-input-search.js';
+import { defineCustomElement as defineXplInputTime } from '@xplortech/apollo-core/components/xpl-input-time.js';
+import { defineCustomElement as defineXplLargeCard } from '@xplortech/apollo-core/components/xpl-large-card.js';
+import { defineCustomElement as defineXplList } from '@xplortech/apollo-core/components/xpl-list.js';
+import { defineCustomElement as defineXplListItem } from '@xplortech/apollo-core/components/xpl-list-item.js';
+import { defineCustomElement as defineXplMainNav } from '@xplortech/apollo-core/components/xpl-main-nav.js';
+import { defineCustomElement as defineXplModal } from '@xplortech/apollo-core/components/xpl-modal.js';
+import { defineCustomElement as defineXplNavHeaderMenu } from '@xplortech/apollo-core/components/xpl-nav-header-menu.js';
+import { defineCustomElement as defineXplNavItem } from '@xplortech/apollo-core/components/xpl-nav-item.js';
+import { defineCustomElement as defineXplPagination } from '@xplortech/apollo-core/components/xpl-pagination.js';
+import { defineCustomElement as defineXplPanel } from '@xplortech/apollo-core/components/xpl-panel.js';
+import { defineCustomElement as defineXplPopover } from '@xplortech/apollo-core/components/xpl-popover.js';
+import { defineCustomElement as defineXplProgressBar } from '@xplortech/apollo-core/components/xpl-progress-bar.js';
+import { defineCustomElement as defineXplProgressIndicator } from '@xplortech/apollo-core/components/xpl-progress-indicator.js';
+import { defineCustomElement as defineXplRadio } from '@xplortech/apollo-core/components/xpl-radio.js';
+import { defineCustomElement as defineXplSecondaryNav } from '@xplortech/apollo-core/components/xpl-secondary-nav.js';
+import { defineCustomElement as defineXplSelect } from '@xplortech/apollo-core/components/xpl-select.js';
+import { defineCustomElement as defineXplSideNav } from '@xplortech/apollo-core/components/xpl-side-nav.js';
+import { defineCustomElement as defineXplSideNavItem } from '@xplortech/apollo-core/components/xpl-side-nav-item.js';
+import { defineCustomElement as defineXplSkeleton } from '@xplortech/apollo-core/components/xpl-skeleton.js';
+import { defineCustomElement as defineXplSlideout } from '@xplortech/apollo-core/components/xpl-slideout.js';
+import { defineCustomElement as defineXplSpotlight } from '@xplortech/apollo-core/components/xpl-spotlight.js';
+import { defineCustomElement as defineXplTab } from '@xplortech/apollo-core/components/xpl-tab.js';
+import { defineCustomElement as defineXplTabPanel } from '@xplortech/apollo-core/components/xpl-tab-panel.js';
+import { defineCustomElement as defineXplTable } from '@xplortech/apollo-core/components/xpl-table.js';
+import { defineCustomElement as defineXplTableHeader } from '@xplortech/apollo-core/components/xpl-table-header.js';
+import { defineCustomElement as defineXplTableHeaderCell } from '@xplortech/apollo-core/components/xpl-table-header-cell.js';
+import { defineCustomElement as defineXplTabs } from '@xplortech/apollo-core/components/xpl-tabs.js';
+import { defineCustomElement as defineXplTag } from '@xplortech/apollo-core/components/xpl-tag.js';
+import { defineCustomElement as defineXplToast } from '@xplortech/apollo-core/components/xpl-toast.js';
+import { defineCustomElement as defineXplToggle } from '@xplortech/apollo-core/components/xpl-toggle.js';
+import { defineCustomElement as defineXplToolbar } from '@xplortech/apollo-core/components/xpl-toolbar.js';
+import { defineCustomElement as defineXplTooltip } from '@xplortech/apollo-core/components/xpl-tooltip.js';
+import { defineCustomElement as defineXplTopNav } from '@xplortech/apollo-core/components/xpl-top-nav.js';
+import { defineCustomElement as defineXplTopNavItem } from '@xplortech/apollo-core/components/xpl-top-nav-item.js';
+import { defineCustomElement as defineXplTopNavMenu } from '@xplortech/apollo-core/components/xpl-top-nav-menu.js';
+import { defineCustomElement as defineXplUtilityBar } from '@xplortech/apollo-core/components/xpl-utility-bar.js';
+let XplAccordion = class XplAccordion {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplAccordion = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplAccordion,
+        inputs: ['borderType', 'contentId', 'description', 'header', 'initialExpanded', 'size'],
+        methods: ['parentCheckboxChange']
+    }),
+    Component({
+        selector: 'xpl-accordion',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['borderType', 'contentId', 'description', 'header', 'initialExpanded', 'size'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplAccordion);
+export { XplAccordion };
+let XplApplicationShell = class XplApplicationShell {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplApplicationShell = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplApplicationShell,
+        inputs: ['isNavOpenAtStartup', 'navWidth', 'withSubnav', 'withUtility']
+    }),
+    Component({
+        selector: 'xpl-application-shell',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['isNavOpenAtStartup', 'navWidth', 'withSubnav', 'withUtility'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplApplicationShell);
+export { XplApplicationShell };
+let XplAvatar = class XplAvatar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplAvatar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplAvatar,
+        inputs: ['color', 'disabled', 'groupData', 'href', 'name', 'size', 'src', 'status', 'subText', 'target', 'variant']
+    }),
+    Component({
+        selector: 'xpl-avatar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['color', 'disabled', 'groupData', 'href', 'name', 'size', 'src', 'status', 'subText', 'target', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplAvatar);
+export { XplAvatar };
+let XplBackdrop = class XplBackdrop {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplBackdrop = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplBackdrop,
+        inputs: ['relative']
+    }),
+    Component({
+        selector: 'xpl-backdrop',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['relative'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplBackdrop);
+export { XplBackdrop };
+let XplBadge = class XplBadge {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplBadge = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplBadge,
+        inputs: ['bordered', 'dot', 'dotOnly', 'shape', 'size', 'variant']
+    }),
+    Component({
+        selector: 'xpl-badge',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['bordered', 'dot', 'dotOnly', 'shape', 'size', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplBadge);
+export { XplBadge };
+let XplBanner = class XplBanner {
+    constructor(c, r, z) {
+        this.z = z;
+        this.action = new EventEmitter();
+        this.dismiss = new EventEmitter();
+        this.secondaryAction = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplBanner.prototype, "action", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplBanner.prototype, "dismiss", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplBanner.prototype, "secondaryAction", void 0);
+XplBanner = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplBanner,
+        inputs: ['actionText', 'appearance', 'description', 'hasIcon', 'heading', 'isDismissible', 'isSection', 'secondaryActionText', 'truncateDesc']
+    }),
+    Component({
+        selector: 'xpl-banner',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['actionText', 'appearance', 'description', 'hasIcon', 'heading', 'isDismissible', 'isSection', 'secondaryActionText', 'truncateDesc'],
+        outputs: ['action', 'dismiss', 'secondaryAction'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplBanner);
+export { XplBanner };
+let XplBreadcrumbItem = class XplBreadcrumbItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplBreadcrumbItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplBreadcrumbItem
+    }),
+    Component({
+        selector: 'xpl-breadcrumb-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplBreadcrumbItem);
+export { XplBreadcrumbItem };
+let XplBreadcrumbs = class XplBreadcrumbs {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplBreadcrumbs = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplBreadcrumbs
+    }),
+    Component({
+        selector: 'xpl-breadcrumbs',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplBreadcrumbs);
+export { XplBreadcrumbs };
+let XplButton = class XplButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplButton = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplButton,
+        inputs: ['controlAttrs', 'disabled', 'form', 'fullWidth', 'icon', 'iconOnly', 'iconPosition', 'isLoading', 'link', 'name', 'sentiment', 'size', 'state', 'type', 'value', 'variant']
+    }),
+    Component({
+        selector: 'xpl-button',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['controlAttrs', 'disabled', 'form', 'fullWidth', 'icon', 'iconOnly', 'iconPosition', 'isLoading', 'link', 'name', 'sentiment', 'size', 'state', 'type', 'value', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplButton);
+export { XplButton };
+let XplButtonRow = class XplButtonRow {
+    constructor(c, r, z) {
+        this.z = z;
+        this.clickPrimary = new EventEmitter();
+        this.clickSecondary = new EventEmitter();
+        this.clickTertiary = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplButtonRow.prototype, "clickPrimary", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplButtonRow.prototype, "clickSecondary", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplButtonRow.prototype, "clickTertiary", void 0);
+XplButtonRow = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplButtonRow,
+        inputs: ['primary', 'secondary', 'tertiary']
+    }),
+    Component({
+        selector: 'xpl-button-row',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['primary', 'secondary', 'tertiary'],
+        outputs: ['clickPrimary', 'clickSecondary', 'clickTertiary'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplButtonRow);
+export { XplButtonRow };
+let XplCalendar = class XplCalendar {
+    constructor(c, r, z) {
+        this.z = z;
+        this.dateSelected = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplCalendar.prototype, "dateSelected", void 0);
+XplCalendar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplCalendar,
+        inputs: ['dateFormat', 'defaultDate', 'inputId', 'max', 'min', 'mode'],
+        methods: ['setDate']
+    }),
+    Component({
+        selector: 'xpl-calendar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['dateFormat', 'defaultDate', 'inputId', 'max', 'min', 'mode'],
+        outputs: ['dateSelected'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplCalendar);
+export { XplCalendar };
+let XplCheckbox = class XplCheckbox {
+    constructor(c, r, z) {
+        this.z = z;
+        this.checkboxChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplCheckbox.prototype, "checkboxChange", void 0);
+XplCheckbox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplCheckbox,
+        inputs: ['ariaLabel', 'checked', 'dataId', 'description', 'disabled', 'indeterminate', 'name', 'required', 'styled', 'value']
+    }),
+    Component({
+        selector: 'xpl-checkbox',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['ariaLabel', 'checked', 'dataId', 'description', 'disabled', 'indeterminate', 'name', 'required', 'styled', 'value'],
+        outputs: ['checkboxChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplCheckbox);
+export { XplCheckbox };
+let XplChoicelist = class XplChoicelist {
+    constructor(c, r, z) {
+        this.z = z;
+        this.choicelistChange = new EventEmitter();
+        this.choicelistValueChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplChoicelist.prototype, "choicelistChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplChoicelist.prototype, "choicelistValueChange", void 0);
+XplChoicelist = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplChoicelist,
+        inputs: ['choices', 'description', 'heading', 'multi', 'name', 'styled']
+    }),
+    Component({
+        selector: 'xpl-choicelist',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['choices', 'description', 'heading', 'multi', 'name', 'styled'],
+        outputs: ['choicelistChange', 'choicelistValueChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplChoicelist);
+export { XplChoicelist };
+let XplContentArea = class XplContentArea {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplContentArea = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplContentArea,
+        inputs: ['size']
+    }),
+    Component({
+        selector: 'xpl-content-area',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['size'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplContentArea);
+export { XplContentArea };
+let XplDashboard = class XplDashboard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDashboard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDashboard
+    }),
+    Component({
+        selector: 'xpl-dashboard',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDashboard);
+export { XplDashboard };
+let XplDataCard = class XplDataCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDataCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDataCard,
+        inputs: ['detail', 'icon', 'leadingIcon', 'link', 'name', 'shortStat', 'smallStat', 'smallStatIcon', 'smallStatVariant', 'stat', 'tooltipTextSmallStat', 'tooltipTextStat', 'variant']
+    }),
+    Component({
+        selector: 'xpl-data-card',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['detail', 'icon', 'leadingIcon', 'link', 'name', 'shortStat', 'smallStat', 'smallStatIcon', 'smallStatVariant', 'stat', 'tooltipTextSmallStat', 'tooltipTextStat', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDataCard);
+export { XplDataCard };
+let XplDivider = class XplDivider {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDivider = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDivider,
+        inputs: ['tier']
+    }),
+    Component({
+        selector: 'xpl-divider',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['tier'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDivider);
+export { XplDivider };
+let XplDropdown = class XplDropdown {
+    constructor(c, r, z) {
+        this.z = z;
+        this.isOpenChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplDropdown.prototype, "isOpenChange", void 0);
+XplDropdown = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDropdown,
+        inputs: ['anchorToTrigger', 'closeOnSelect', 'flipFallbackPlacements', 'isOpen', 'mode', 'options', 'placement', 'selectOnFocus', 'selectedValues', 'triggerId', 'update'],
+        methods: ['handleSelect']
+    }),
+    Component({
+        selector: 'xpl-dropdown',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['anchorToTrigger', 'closeOnSelect', 'flipFallbackPlacements', 'isOpen', 'mode', 'options', 'placement', 'selectOnFocus', 'selectedValues', 'triggerId', 'update'],
+        outputs: ['isOpenChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDropdown);
+export { XplDropdown };
+let XplDropdownGroup = class XplDropdownGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDropdownGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDropdownGroup,
+        inputs: ['groupName', 'options']
+    }),
+    Component({
+        selector: 'xpl-dropdown-group',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['groupName', 'options'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDropdownGroup);
+export { XplDropdownGroup };
+let XplDropdownHeading = class XplDropdownHeading {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDropdownHeading = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDropdownHeading,
+        inputs: ['label']
+    }),
+    Component({
+        selector: 'xpl-dropdown-heading',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['label'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDropdownHeading);
+export { XplDropdownHeading };
+let XplDropdownOption = class XplDropdownOption {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDropdownOption = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDropdownOption,
+        inputs: ['icon', 'isDisabled', 'isSelected', 'label', 'subtitle', 'value']
+    }),
+    Component({
+        selector: 'xpl-dropdown-option',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['icon', 'isDisabled', 'isSelected', 'label', 'subtitle', 'value'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDropdownOption);
+export { XplDropdownOption };
+let XplDynamicTable = class XplDynamicTable {
+    constructor(c, r, z) {
+        this.z = z;
+        this.selectedItemCountChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplDynamicTable.prototype, "selectedItemCountChange", void 0);
+XplDynamicTable = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDynamicTable
+    }),
+    Component({
+        selector: 'xpl-dynamic-table',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+        outputs: ['selectedItemCountChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDynamicTable);
+export { XplDynamicTable };
+let XplDynamicTableCell = class XplDynamicTableCell {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDynamicTableCell = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDynamicTableCell,
+        inputs: ['disabled']
+    }),
+    Component({
+        selector: 'xpl-dynamic-table-cell',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDynamicTableCell);
+export { XplDynamicTableCell };
+let XplDynamicTableRow = class XplDynamicTableRow {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplDynamicTableRow = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplDynamicTableRow,
+        inputs: ['disabled', 'selected']
+    }),
+    Component({
+        selector: 'xpl-dynamic-table-row',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'selected'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplDynamicTableRow);
+export { XplDynamicTableRow };
+let XplGrid = class XplGrid {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplGrid = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplGrid
+    }),
+    Component({
+        selector: 'xpl-grid',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplGrid);
+export { XplGrid };
+let XplGridItem = class XplGridItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplGridItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplGridItem,
+        inputs: ['lg', 'md', 'sm', 'xs']
+    }),
+    Component({
+        selector: 'xpl-grid-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['lg', 'md', 'sm', 'xs'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplGridItem);
+export { XplGridItem };
+let XplHeaderAccordion = class XplHeaderAccordion {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplHeaderAccordion = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplHeaderAccordion,
+        inputs: ['contentId', 'disabled', 'hasCheckbox', 'initialExpanded', 'selectedCount']
+    }),
+    Component({
+        selector: 'xpl-header-accordion',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['contentId', 'disabled', 'hasCheckbox', 'initialExpanded', 'selectedCount'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplHeaderAccordion);
+export { XplHeaderAccordion };
+let XplIcon = class XplIcon {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplIcon = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplIcon,
+        inputs: ['backgroundColor', 'icon', 'size']
+    }),
+    Component({
+        selector: 'xpl-icon',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['backgroundColor', { name: 'icon', required: true }, 'size'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplIcon);
+export { XplIcon };
+let XplInput = class XplInput {
+    constructor(c, r, z) {
+        this.z = z;
+        this.blurEvent = new EventEmitter();
+        this.focusEvent = new EventEmitter();
+        this.inputEvent = new EventEmitter();
+        this.search = new EventEmitter();
+        this.valueChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInput.prototype, "blurEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInput.prototype, "focusEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInput.prototype, "inputEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInput.prototype, "search", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInput.prototype, "valueChange", void 0);
+XplInput = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInput,
+        inputs: ['_id', 'accept', 'allowCustomOption', 'ariaLabel', 'autocomplete', 'dateFormat', 'defaultCountry', 'description', 'disabled', 'error', 'hideAcceptText', 'hideEyeDropper', 'hideFileNames', 'hideTriggerOnSelect', 'isInternational', 'label', 'max', 'maxCharacterCount', 'min', 'mode', 'multiline', 'multiple', 'name', 'placeholder', 'post', 'pre', 'preferredCountries', 'readonly', 'required', 'shape', 'step', 'timeFormat', 'type', 'value'],
+        methods: ['setFocus']
+    }),
+    Component({
+        selector: 'xpl-input',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['_id', 'accept', 'allowCustomOption', 'ariaLabel', 'autocomplete', 'dateFormat', 'defaultCountry', 'description', 'disabled', 'error', 'hideAcceptText', 'hideEyeDropper', 'hideFileNames', 'hideTriggerOnSelect', 'isInternational', 'label', 'max', 'maxCharacterCount', 'min', 'mode', 'multiline', 'multiple', 'name', 'placeholder', 'post', 'pre', 'preferredCountries', 'readonly', 'required', 'shape', 'step', 'timeFormat', 'type', 'value'],
+        outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInput);
+export { XplInput };
+let XplInputColor = class XplInputColor {
+    constructor(c, r, z) {
+        this.z = z;
+        this.inputChange = new EventEmitter();
+        this.hasErrorStateChanged = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputColor.prototype, "inputChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputColor.prototype, "hasErrorStateChanged", void 0);
+XplInputColor = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputColor,
+        inputs: ['disabled', 'hideEyeDropper', 'placeholder', 'required', 'value']
+    }),
+    Component({
+        selector: 'xpl-input-color',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'hideEyeDropper', 'placeholder', 'required', 'value'],
+        outputs: ['inputChange', 'hasErrorStateChanged'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputColor);
+export { XplInputColor };
+let XplInputDate = class XplInputDate {
+    constructor(c, r, z) {
+        this.z = z;
+        this.valueChange = new EventEmitter();
+        this.hasErrorStateChanged = new EventEmitter();
+        this.rangeSelected = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputDate.prototype, "valueChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputDate.prototype, "hasErrorStateChanged", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputDate.prototype, "rangeSelected", void 0);
+XplInputDate = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputDate,
+        inputs: ['dateFormat', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'post', 'pre', 'readonly', 'required', 'value']
+    }),
+    Component({
+        selector: 'xpl-input-date',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['dateFormat', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'post', 'pre', 'readonly', 'required', 'value'],
+        outputs: ['valueChange', 'hasErrorStateChanged', 'rangeSelected'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputDate);
+export { XplInputDate };
+let XplInputFile = class XplInputFile {
+    constructor(c, r, z) {
+        this.z = z;
+        this.inputChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputFile.prototype, "inputChange", void 0);
+XplInputFile = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputFile,
+        inputs: ['_id', 'accept', 'disabled', 'hideAcceptText', 'hideFileNames', 'hideTriggerOnSelect', 'multiple', 'name'],
+        methods: ['removeFileByIndex']
+    }),
+    Component({
+        selector: 'xpl-input-file',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['_id', 'accept', 'disabled', 'hideAcceptText', 'hideFileNames', 'hideTriggerOnSelect', 'multiple', 'name'],
+        outputs: ['inputChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputFile);
+export { XplInputFile };
+let XplInputPhone = class XplInputPhone {
+    constructor(c, r, z) {
+        this.z = z;
+        this.hasErrorStateChanged = new EventEmitter();
+        this.valueChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputPhone.prototype, "hasErrorStateChanged", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputPhone.prototype, "valueChange", void 0);
+XplInputPhone = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputPhone,
+        inputs: ['defaultCountry', 'disabled', 'error', 'inputId', 'isInternational', 'name', 'placeholder', 'preferredCountries', 'readonly', 'required', 'value']
+    }),
+    Component({
+        selector: 'xpl-input-phone',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['defaultCountry', 'disabled', 'error', 'inputId', 'isInternational', 'name', 'placeholder', 'preferredCountries', 'readonly', 'required', 'value'],
+        outputs: ['hasErrorStateChanged', 'valueChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputPhone);
+export { XplInputPhone };
+let XplInputSearch = class XplInputSearch {
+    constructor(c, r, z) {
+        this.z = z;
+        this.blurEvent = new EventEmitter();
+        this.focusEvent = new EventEmitter();
+        this.inputEvent = new EventEmitter();
+        this.search = new EventEmitter();
+        this.valueChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputSearch.prototype, "blurEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputSearch.prototype, "focusEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputSearch.prototype, "inputEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputSearch.prototype, "search", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputSearch.prototype, "valueChange", void 0);
+XplInputSearch = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputSearch,
+        inputs: ['ariaLabel', 'autocomplete', 'disabled', 'errorMessageId', 'hasError', 'hasVisibleLabel', 'inputId', 'name', 'placeholder', 'readonly', 'required', 'shape', 'value'],
+        methods: ['setFocus']
+    }),
+    Component({
+        selector: 'xpl-input-search',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['ariaLabel', 'autocomplete', 'disabled', 'errorMessageId', 'hasError', 'hasVisibleLabel', { name: 'inputId', required: true }, 'name', 'placeholder', 'readonly', 'required', 'shape', 'value'],
+        outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputSearch);
+export { XplInputSearch };
+let XplInputTime = class XplInputTime {
+    constructor(c, r, z) {
+        this.z = z;
+        this.valueChange = new EventEmitter();
+        this.hasErrorStateChanged = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputTime.prototype, "valueChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplInputTime.prototype, "hasErrorStateChanged", void 0);
+XplInputTime = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplInputTime,
+        inputs: ['allowCustomOption', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'readonly', 'required', 'step', 'timeFormat', 'value']
+    }),
+    Component({
+        selector: 'xpl-input-time',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['allowCustomOption', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'readonly', 'required', 'step', 'timeFormat', 'value'],
+        outputs: ['valueChange', 'hasErrorStateChanged'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplInputTime);
+export { XplInputTime };
+let XplLargeCard = class XplLargeCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplLargeCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplLargeCard,
+        inputs: ['description', 'link', 'name']
+    }),
+    Component({
+        selector: 'xpl-large-card',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['description', 'link', 'name'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplLargeCard);
+export { XplLargeCard };
+let XplList = class XplList {
+    constructor(c, r, z) {
+        this.z = z;
+        this.itemSelect = new EventEmitter();
+        this.orderChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplList.prototype, "itemSelect", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplList.prototype, "orderChange", void 0);
+XplList = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplList,
+        inputs: ['items', 'label', 'labelledBy', 'reorderable', 'selectable'],
+        methods: ['clearSelection']
+    }),
+    Component({
+        selector: 'xpl-list',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['items', 'label', 'labelledBy', 'reorderable', 'selectable'],
+        outputs: ['itemSelect', 'orderChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplList);
+export { XplList };
+let XplListItem = class XplListItem {
+    constructor(c, r, z) {
+        this.z = z;
+        this.itemDragEnd = new EventEmitter();
+        this.itemDragStart = new EventEmitter();
+        this.itemDrop = new EventEmitter();
+        this.itemSelect = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplListItem.prototype, "itemDragEnd", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplListItem.prototype, "itemDragStart", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplListItem.prototype, "itemDrop", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplListItem.prototype, "itemSelect", void 0);
+XplListItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplListItem,
+        inputs: ['disabled', 'error', 'hidden', 'href', 'item', 'itemId', 'keyboardActive', 'radioName', 'reorderable', 'selectable', 'selected', 'showDivider', 'titleBadgeVariant']
+    }),
+    Component({
+        selector: 'xpl-list-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'error', 'hidden', 'href', 'item', 'itemId', 'keyboardActive', 'radioName', 'reorderable', 'selectable', 'selected', 'showDivider', 'titleBadgeVariant'],
+        outputs: ['itemDragEnd', 'itemDragStart', 'itemDrop', 'itemSelect'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplListItem);
+export { XplListItem };
+let XplMainNav = class XplMainNav {
+    constructor(c, r, z) {
+        this.z = z;
+        this.navWidth = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplMainNav.prototype, "navWidth", void 0);
+XplMainNav = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplMainNav,
+        inputs: ['width']
+    }),
+    Component({
+        selector: 'xpl-main-nav',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['width'],
+        outputs: ['navWidth'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplMainNav);
+export { XplMainNav };
+let XplModal = class XplModal {
+    constructor(c, r, z) {
+        this.z = z;
+        this.modalClosed = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplModal.prototype, "modalClosed", void 0);
+XplModal = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplModal,
+        inputs: ['isOpen', 'size', 'variant']
+    }),
+    Component({
+        selector: 'xpl-modal',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['isOpen', 'size', 'variant'],
+        outputs: ['modalClosed'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplModal);
+export { XplModal };
+let XplNavHeaderMenu = class XplNavHeaderMenu {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplNavHeaderMenu = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplNavHeaderMenu,
+        inputs: ['email', 'username']
+    }),
+    Component({
+        selector: 'xpl-nav-header-menu',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['email', 'username'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplNavHeaderMenu);
+export { XplNavHeaderMenu };
+let XplNavItem = class XplNavItem {
+    constructor(c, r, z) {
+        this.z = z;
+        this.navOpen = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplNavItem.prototype, "navOpen", void 0);
+XplNavItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplNavItem,
+        inputs: ['navControl']
+    }),
+    Component({
+        selector: 'xpl-nav-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['navControl'],
+        outputs: ['navOpen'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplNavItem);
+export { XplNavItem };
+let XplPagination = class XplPagination {
+    constructor(c, r, z) {
+        this.z = z;
+        this.pageChange = new EventEmitter();
+        this.rowsPerPageChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplPagination.prototype, "pageChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplPagination.prototype, "rowsPerPageChange", void 0);
+XplPagination = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplPagination,
+        inputs: ['currentPage', 'rowsPerPageOptions', 'selectedRowsPerPage', 'totalPages', 'withPageControl']
+    }),
+    Component({
+        selector: 'xpl-pagination',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['currentPage', 'rowsPerPageOptions', 'selectedRowsPerPage', 'totalPages', 'withPageControl'],
+        outputs: ['pageChange', 'rowsPerPageChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplPagination);
+export { XplPagination };
+let XplPanel = class XplPanel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplPanel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplPanel,
+        inputs: ['accent', 'padding']
+    }),
+    Component({
+        selector: 'xpl-panel',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['accent', 'padding'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplPanel);
+export { XplPanel };
+let XplPopover = class XplPopover {
+    constructor(c, r, z) {
+        this.z = z;
+        this.isOpenChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplPopover.prototype, "isOpenChange", void 0);
+XplPopover = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplPopover,
+        inputs: ['disabled', 'display', 'isOpen', 'position']
+    }),
+    Component({
+        selector: 'xpl-popover',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'display', 'isOpen', 'position'],
+        outputs: ['isOpenChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplPopover);
+export { XplPopover };
+let XplProgressBar = class XplProgressBar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplProgressBar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplProgressBar,
+        inputs: ['helperText', 'label', 'max', 'size', 'value', 'variant']
+    }),
+    Component({
+        selector: 'xpl-progress-bar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['helperText', 'label', 'max', 'size', 'value', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplProgressBar);
+export { XplProgressBar };
+let XplProgressIndicator = class XplProgressIndicator {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplProgressIndicator = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplProgressIndicator,
+        inputs: ['currentStep', 'layout', 'showLabels', 'showNumbers', 'steps']
+    }),
+    Component({
+        selector: 'xpl-progress-indicator',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['currentStep', 'layout', 'showLabels', 'showNumbers', 'steps'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplProgressIndicator);
+export { XplProgressIndicator };
+let XplRadio = class XplRadio {
+    constructor(c, r, z) {
+        this.z = z;
+        this.radioChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplRadio.prototype, "radioChange", void 0);
+XplRadio = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplRadio,
+        inputs: ['checked', 'description', 'disabled', 'name', 'required', 'selectedValue', 'styled', 'value']
+    }),
+    Component({
+        selector: 'xpl-radio',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['checked', 'description', 'disabled', 'name', 'required', 'selectedValue', 'styled', 'value'],
+        outputs: ['radioChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplRadio);
+export { XplRadio };
+let XplSecondaryNav = class XplSecondaryNav {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplSecondaryNav = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSecondaryNav
+    }),
+    Component({
+        selector: 'xpl-secondary-nav',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSecondaryNav);
+export { XplSecondaryNav };
+let XplSelect = class XplSelect {
+    constructor(c, r, z) {
+        this.z = z;
+        this.selectChange = new EventEmitter();
+        this.changeEvent = new EventEmitter();
+        this.dropdownStateChange = new EventEmitter();
+        this.triggerDropdown = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSelect.prototype, "selectChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSelect.prototype, "changeEvent", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSelect.prototype, "dropdownStateChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSelect.prototype, "triggerDropdown", void 0);
+XplSelect = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSelect,
+        inputs: ['choices', 'classNames', 'customDisplayValue', 'description', 'disabled', 'dropdownFlipFallbackPlacements', 'dropdownPlacement', 'error', 'label', 'mode', 'name', 'placeholder', 'selectIcon', 'selectedValues', 'truncate'],
+        methods: ['reset']
+    }),
+    Component({
+        selector: 'xpl-select',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['choices', 'classNames', 'customDisplayValue', 'description', 'disabled', 'dropdownFlipFallbackPlacements', 'dropdownPlacement', 'error', 'label', 'mode', 'name', 'placeholder', 'selectIcon', 'selectedValues', 'truncate'],
+        outputs: ['selectChange', 'changeEvent', 'dropdownStateChange', 'triggerDropdown'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSelect);
+export { XplSelect };
+let XplSideNav = class XplSideNav {
+    constructor(c, r, z) {
+        this.z = z;
+        this.openChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSideNav.prototype, "openChange", void 0);
+XplSideNav = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSideNav,
+        inputs: ['label', 'open'],
+        methods: ['toggle', 'setOpen']
+    }),
+    Component({
+        selector: 'xpl-side-nav',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['label', 'open'],
+        outputs: ['openChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSideNav);
+export { XplSideNav };
+let XplSideNavItem = class XplSideNavItem {
+    constructor(c, r, z) {
+        this.z = z;
+        this.expandedChange = new EventEmitter();
+        this.navClick = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSideNavItem.prototype, "expandedChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSideNavItem.prototype, "navClick", void 0);
+XplSideNavItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSideNavItem,
+        inputs: ['disabled', 'expanded', 'hasChildren', 'hidden', 'icon', 'label', 'link', 'selected']
+    }),
+    Component({
+        selector: 'xpl-side-nav-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'expanded', 'hasChildren', 'hidden', 'icon', 'label', 'link', 'selected'],
+        outputs: ['expandedChange', 'navClick'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSideNavItem);
+export { XplSideNavItem };
+let XplSkeleton = class XplSkeleton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplSkeleton = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSkeleton,
+        inputs: ['classNames', 'fullWidth', 'height', 'margin', 'shape', 'size', 'width']
+    }),
+    Component({
+        selector: 'xpl-skeleton',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['classNames', 'fullWidth', 'height', 'margin', 'shape', 'size', 'width'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSkeleton);
+export { XplSkeleton };
+let XplSlideout = class XplSlideout {
+    constructor(c, r, z) {
+        this.z = z;
+        this.isOpenChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSlideout.prototype, "isOpenChange", void 0);
+XplSlideout = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSlideout,
+        inputs: ['backdrop', 'isOpen', 'showFooter', 'variant']
+    }),
+    Component({
+        selector: 'xpl-slideout',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['backdrop', 'isOpen', 'showFooter', 'variant'],
+        outputs: ['isOpenChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSlideout);
+export { XplSlideout };
+let XplSpotlight = class XplSpotlight {
+    constructor(c, r, z) {
+        this.z = z;
+        this.dismiss = new EventEmitter();
+        this.primaryAction = new EventEmitter();
+        this.secondaryAction = new EventEmitter();
+        this.targetClick = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSpotlight.prototype, "dismiss", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSpotlight.prototype, "primaryAction", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSpotlight.prototype, "secondaryAction", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplSpotlight.prototype, "targetClick", void 0);
+XplSpotlight = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplSpotlight,
+        inputs: ['actionLayout', 'anchorPosition', 'body', 'currentStep', 'heading', 'isDismissible', 'isOpen', 'primaryActionLabel', 'secondaryActionLabel', 'showActions', 'showImage', 'showSteps', 'target', 'totalSteps']
+    }),
+    Component({
+        selector: 'xpl-spotlight',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['actionLayout', 'anchorPosition', 'body', 'currentStep', 'heading', 'isDismissible', 'isOpen', 'primaryActionLabel', 'secondaryActionLabel', 'showActions', 'showImage', 'showSteps', 'target', 'totalSteps'],
+        outputs: ['dismiss', 'primaryAction', 'secondaryAction', 'targetClick'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplSpotlight);
+export { XplSpotlight };
+let XplTab = class XplTab {
+    constructor(c, r, z) {
+        this.z = z;
+        this.tabChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTab.prototype, "tabChange", void 0);
+XplTab = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTab,
+        inputs: ['disabled', 'groupDisabled', 'icon', 'iconPosition', 'selected', 'target']
+    }),
+    Component({
+        selector: 'xpl-tab',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'groupDisabled', 'icon', 'iconPosition', 'selected', 'target'],
+        outputs: ['tabChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTab);
+export { XplTab };
+let XplTabPanel = class XplTabPanel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplTabPanel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTabPanel,
+        inputs: ['selected', 'target']
+    }),
+    Component({
+        selector: 'xpl-tab-panel',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['selected', 'target'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTabPanel);
+export { XplTabPanel };
+let XplTable = class XplTable {
+    constructor(c, r, z) {
+        this.z = z;
+        this.tableSelect = new EventEmitter();
+        this.sortChanged = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTable.prototype, "tableSelect", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTable.prototype, "sortChanged", void 0);
+XplTable = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTable,
+        inputs: ['columns', 'data', 'footer', 'freeze', 'isSortable', 'multiselect', 'selectedValues', 'sortableColumns', 'striped']
+    }),
+    Component({
+        selector: 'xpl-table',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['columns', 'data', 'footer', 'freeze', 'isSortable', 'multiselect', 'selectedValues', 'sortableColumns', 'striped'],
+        outputs: ['tableSelect', 'sortChanged'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTable);
+export { XplTable };
+let XplTableHeader = class XplTableHeader {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplTableHeader = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTableHeader
+    }),
+    Component({
+        selector: 'xpl-table-header',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: [],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTableHeader);
+export { XplTableHeader };
+let XplTableHeaderCell = class XplTableHeaderCell {
+    constructor(c, r, z) {
+        this.z = z;
+        this.sortChanged = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTableHeaderCell.prototype, "sortChanged", void 0);
+XplTableHeaderCell = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTableHeaderCell,
+        inputs: ['icon', 'label', 'sortable', 'type', 'width']
+    }),
+    Component({
+        selector: 'xpl-table-header-cell',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['icon', 'label', 'sortable', 'type', 'width'],
+        outputs: ['sortChanged'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTableHeaderCell);
+export { XplTableHeaderCell };
+let XplTabs = class XplTabs {
+    constructor(c, r, z) {
+        this.z = z;
+        this.tabChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTabs.prototype, "tabChange", void 0);
+XplTabs = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTabs,
+        inputs: ['disabled', 'fullWidth', 'type', 'value']
+    }),
+    Component({
+        selector: 'xpl-tabs',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'fullWidth', 'type', 'value'],
+        outputs: ['tabChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTabs);
+export { XplTabs };
+let XplTag = class XplTag {
+    constructor(c, r, z) {
+        this.z = z;
+        this.close = new EventEmitter();
+        this.tagDragEnd = new EventEmitter();
+        this.tagDragStart = new EventEmitter();
+        this.tagRemove = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTag.prototype, "close", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTag.prototype, "tagDragEnd", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTag.prototype, "tagDragStart", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTag.prototype, "tagRemove", void 0);
+XplTag = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTag,
+        inputs: ['disabled', 'dismissible', 'isDraggable', 'size', 'tagId']
+    }),
+    Component({
+        selector: 'xpl-tag',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['disabled', 'dismissible', 'isDraggable', 'size', 'tagId'],
+        outputs: ['close', 'tagDragEnd', 'tagDragStart', 'tagRemove'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTag);
+export { XplTag };
+let XplToast = class XplToast {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplToast = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplToast,
+        inputs: ['caption', 'dismissable', 'showIcon', 'timeout', 'variant']
+    }),
+    Component({
+        selector: 'xpl-toast',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['caption', 'dismissable', 'showIcon', 'timeout', 'variant'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplToast);
+export { XplToast };
+let XplToggle = class XplToggle {
+    constructor(c, r, z) {
+        this.z = z;
+        this.toggleChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplToggle.prototype, "toggleChange", void 0);
+XplToggle = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplToggle,
+        inputs: ['checked', 'description', 'disabled', 'heading', 'label', 'name', 'variant']
+    }),
+    Component({
+        selector: 'xpl-toggle',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['checked', 'description', 'disabled', 'heading', 'label', 'name', 'variant'],
+        outputs: ['toggleChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplToggle);
+export { XplToggle };
+let XplToolbar = class XplToolbar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplToolbar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplToolbar,
+        inputs: ['selectedItemCount']
+    }),
+    Component({
+        selector: 'xpl-toolbar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['selectedItemCount'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplToolbar);
+export { XplToolbar };
+let XplTooltip = class XplTooltip {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplTooltip = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTooltip,
+        inputs: ['hideArrow', 'position', 'text']
+    }),
+    Component({
+        selector: 'xpl-tooltip',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['hideArrow', 'position', 'text'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTooltip);
+export { XplTooltip };
+let XplTopNav = class XplTopNav {
+    constructor(c, r, z) {
+        this.z = z;
+        this.brandClick = new EventEmitter();
+        this.navOpen = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTopNav.prototype, "brandClick", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTopNav.prototype, "navOpen", void 0);
+XplTopNav = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTopNav,
+        inputs: ['brandHref', 'brandLogo', 'brandName', 'childAccountLabel', 'label', 'navControl']
+    }),
+    Component({
+        selector: 'xpl-top-nav',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['brandHref', 'brandLogo', 'brandName', 'childAccountLabel', 'label', 'navControl'],
+        outputs: ['brandClick', 'navOpen'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTopNav);
+export { XplTopNav };
+let XplTopNavItem = class XplTopNavItem {
+    constructor(c, r, z) {
+        this.z = z;
+        this.navItemClick = new EventEmitter();
+        this.openChange = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTopNavItem.prototype, "navItemClick", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplTopNavItem.prototype, "openChange", void 0);
+XplTopNavItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTopNavItem,
+        inputs: ['active', 'description', 'href', 'icon', 'itemAriaLabel', 'label', 'open', 'openMode', 'selected'],
+        methods: ['closeMenu', 'openMenu', 'toggleMenu']
+    }),
+    Component({
+        selector: 'xpl-top-nav-item',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['active', 'description', 'href', 'icon', 'itemAriaLabel', 'label', 'open', 'openMode', 'selected'],
+        outputs: ['navItemClick', 'openChange'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTopNavItem);
+export { XplTopNavItem };
+let XplTopNavMenu = class XplTopNavMenu {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+XplTopNavMenu = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplTopNavMenu,
+        inputs: ['label']
+    }),
+    Component({
+        selector: 'xpl-top-nav-menu',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['label'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplTopNavMenu);
+export { XplTopNavMenu };
+let XplUtilityBar = class XplUtilityBar {
+    constructor(c, r, z) {
+        this.z = z;
+        this.navOpen = new EventEmitter();
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], XplUtilityBar.prototype, "navOpen", void 0);
+XplUtilityBar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineXplUtilityBar,
+        inputs: ['isNavOpenAtStartup', 'navControl']
+    }),
+    Component({
+        selector: 'xpl-utility-bar',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        template: '<ng-content></ng-content>',
+        inputs: ['isNavOpenAtStartup', 'navControl'],
+        outputs: ['navOpen'],
+    }),
+    __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
+], XplUtilityBar);
+export { XplUtilityBar };
+//# sourceMappingURL=proxies.js.map