@globalpayments/vega-angular 2.13.0-backfill-beta.2

package/dist/fesm2020/heartlandone-vega-angular.mjs

@@ -0,0 +1,2360 @@
+import * as i0 from '@angular/core';
+import { Directive, HostListener, Component, ChangeDetectionStrategy, NgModule } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { VegaEventManager, FeatureFlag, VegaEnvManager, FrameworkEnum } from '@globalpayments/vega';
+import { __decorate } from 'tslib';
+import { fromEvent } from 'rxjs';
+import { defineCustomElements } from '@globalpayments/vega/loader';
+import { ResizeObserver } from '@juggle/resize-observer';
+
+class ValueAccessor {
+    constructor(el) {
+        this.el = el;
+        this.onChange = () => {
+            /**/
+        };
+        this.onTouched = () => {
+            /**/
+        };
+    }
+    writeValue(value) {
+        this.el.nativeElement.value = this.lastValue = value == null ? '' : value;
+    }
+    handleChangeEvent(value, semantics) {
+        if (VegaEventManager.getSemantics(this.el.nativeElement).namespace === semantics) {
+            if (value !== this.lastValue) {
+                this.lastValue = value;
+                this.onChange(value);
+            }
+        }
+    }
+    _handleBlurEvent() {
+        this.onTouched();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.el.nativeElement.disabled = isDisabled;
+    }
+}
+ValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: ValueAccessor, selector: "vega-value-accessor", host: { listeners: { "focusout": "_handleBlurEvent()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ValueAccessor, decorators: [{
+            type: Directive,
+            args: [{ selector: 'vega-value-accessor' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { _handleBlurEvent: [{
+                type: HostListener,
+                args: ['focusout']
+            }] } });
+
+class TextValueAccessor extends ValueAccessor {
+    constructor(el) {
+        super(el);
+    }
+}
+TextValueAccessor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TextValueAccessor, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+TextValueAccessor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: TextValueAccessor, selector: "vega-checkbox, vega-checkbox-group, vega-color-picker, vega-combo-box, vega-date-picker, vega-image-uploader, vega-input, vega-input-credit-card, vega-input-range, vega-input-select, vega-radio-group, vega-selection-tile-group, vega-stepper, vega-textarea, vega-time-picker", host: { listeners: { "vegaChange": "handleChangeEvent($event.currentTarget.value, 'vega')", "change": "handleChangeEvent($event.currentTarget.value, 'native')" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: TextValueAccessor,
+            multi: true
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TextValueAccessor, decorators: [{
+            type: Directive,
+            args: [{
+                    /* tslint:disable-next-line:directive-selector */
+                    selector: 'vega-checkbox, vega-checkbox-group, vega-color-picker, vega-combo-box, vega-date-picker, vega-image-uploader, vega-input, vega-input-credit-card, vega-input-range, vega-input-select, vega-radio-group, vega-selection-tile-group, vega-stepper, vega-textarea, vega-time-picker',
+                    host: {
+                        '(vegaChange)': "handleChangeEvent($event.currentTarget.value, 'vega')",
+                        '(change)': "handleChangeEvent($event.currentTarget.value, 'native')"
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: TextValueAccessor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+
+/* eslint-disable */
+/**
+ * ALL: all properties should skip the componentOnReady check
+ * Set<string>: only properties in the Set should skip the componentOnReady check
+ */
+const COMPONENT_ON_READY_IGNORE_MAP = new Map([
+    ['VEGA-TABLE', 'ALL'],
+    ['VEGA-TABLE-HEAD', 'ALL'],
+    ['VEGA-TABLE-HEAD-ROW', 'ALL'],
+    ['VEGA-TABLE-HEAD-CELL', 'ALL'],
+    ['VEGA-TABLE-BODY', 'ALL'],
+    ['VEGA-TABLE-ROW', 'ALL'],
+    ['VEGA-TABLE-CELL', 'ALL'],
+    ['VEGA-TABLE-EXPAND-ROW', 'ALL'],
+]);
+const shouldSkipComponentOnReady = (componentName, propName) => {
+    const props = COMPONENT_ON_READY_IGNORE_MAP.get(componentName);
+    if (!props)
+        return false;
+    return props === 'ALL' || props.has(propName);
+};
+const proxyInputs = (Cmp, inputs) => {
+    const Prototype = Cmp.prototype;
+    inputs.forEach(item => {
+        Object.defineProperty(Prototype, item, {
+            get() {
+                return this.el[item];
+            },
+            set(val) {
+                // Link issues: https://gethired.atlassian.net/browse/GHUI-331
+                // add a beforehand checking to make sure value is only set when component is loaded
+                /*
+                 * Update(2023/10/28): The value should be set directly, so that the initial value can be get in componentWillLoad.
+                 * Link issue https://gethired.atlassian.net/browse/VD-1810
+                 * We need to consider remove the componentOnReady
+                 * https://github.com/ionic-team/stencil-ds-output-targets/blob/main/packages/angular-output-target/angular-component-lib/utils.ts#L13
+                 */
+                if (FeatureFlag.isEnabled('VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD') || this.el.classList.contains('hydrated') || shouldSkipComponentOnReady(this.el.tagName, item)) {
+                    this.z.runOutsideAngular(() => (this.el[item] = val));
+                }
+                else {
+                    this.el.componentOnReady().then(() => {
+                        this.z.runOutsideAngular(() => (this.el[item] = val));
+                    });
+                }
+            }
+        });
+    });
+};
+const proxyMethods = (Cmp, methods) => {
+    const Prototype = Cmp.prototype;
+    methods.forEach(methodName => {
+        Prototype[methodName] = function () {
+            const args = arguments;
+            return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));
+        };
+    });
+};
+const proxyOutputs = (instance, el, events) => {
+    events.forEach(eventName => instance[eventName] = fromEvent(el, eventName));
+};
+const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined &&
+        typeof customElements !== 'undefined' &&
+        !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+// tslint:disable-next-line: only-arrow-functions
+function ProxyCmp(opts) {
+    const decorator = function (cls) {
+        const { defineCustomElementFn, inputs, methods } = opts;
+        if (defineCustomElementFn !== undefined) {
+            defineCustomElementFn();
+        }
+        if (inputs) {
+            proxyInputs(cls, inputs);
+        }
+        if (methods) {
+            proxyMethods(cls, methods);
+        }
+        return cls;
+    };
+    return decorator;
+}
+
+let VegaAccordion = class VegaAccordion {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaExpand', 'accordionExpand']);
+    }
+};
+VegaAccordion.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaAccordion.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaAccordion, selector: "vega-accordion", inputs: { accordionTitle: "accordionTitle", drawsBackground: "drawsBackground", expand: "expand", expandIconAlign: "expandIconAlign", groupId: "groupId", iconPosition: "iconPosition", prefixIcon: "prefixIcon", showExpandIcon: "showExpandIcon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaAccordion = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['accordionTitle', 'drawsBackground', 'expand', 'expandIconAlign', 'groupId', 'iconPosition', 'prefixIcon', 'showExpandIcon']
+    })
+], VegaAccordion);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-accordion',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['accordionTitle', 'drawsBackground', 'expand', 'expandIconAlign', 'groupId', 'iconPosition', 'prefixIcon', 'showExpandIcon']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaAppFooter = class VegaAppFooter {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaAppFooter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAppFooter, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaAppFooter.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaAppFooter, selector: "vega-app-footer", inputs: { additionalLinks: "additionalLinks", content: "content", disclaimerUrlTarget: "disclaimerUrlTarget", hideDefaultLinks: "hideDefaultLinks", privacyPolicyLabel: "privacyPolicyLabel", privacyPolicyUrl: "privacyPolicyUrl", privacyPolicyUrlTarget: "privacyPolicyUrlTarget", showDisclaimer: "showDisclaimer", termOfUseLabel: "termOfUseLabel", termOfUseUrl: "termOfUseUrl", termOfUseUrlTarget: "termOfUseUrlTarget" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaAppFooter = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['additionalLinks', 'content', 'disclaimerUrlTarget', 'hideDefaultLinks', 'privacyPolicyLabel', 'privacyPolicyUrl', 'privacyPolicyUrlTarget', 'showDisclaimer', 'termOfUseLabel', 'termOfUseUrl', 'termOfUseUrlTarget']
+    })
+], VegaAppFooter);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAppFooter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-app-footer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['additionalLinks', 'content', 'disclaimerUrlTarget', 'hideDefaultLinks', 'privacyPolicyLabel', 'privacyPolicyUrl', 'privacyPolicyUrlTarget', 'showDisclaimer', 'termOfUseLabel', 'termOfUseUrl', 'termOfUseUrlTarget']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaAppHeaderButton = class VegaAppHeaderButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click', 'vegaDropdownClick', 'dropdownClick']);
+    }
+};
+VegaAppHeaderButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAppHeaderButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaAppHeaderButton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaAppHeaderButton, selector: "vega-app-header-button", inputs: { avatar: "avatar", avatarPosition: "avatarPosition", dropdown: "dropdown", label: "label", selected: "selected", showBorder: "showBorder", showLabel: "showLabel", showMenuArrowIcon: "showMenuArrowIcon", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaAppHeaderButton = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['avatar', 'avatarPosition', 'dropdown', 'label', 'selected', 'showBorder', 'showLabel', 'showMenuArrowIcon', 'size']
+    })
+], VegaAppHeaderButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaAppHeaderButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-app-header-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['avatar', 'avatarPosition', 'dropdown', 'label', 'selected', 'showBorder', 'showLabel', 'showMenuArrowIcon', 'size']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaBackdrop = class VegaBackdrop {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick']);
+    }
+};
+VegaBackdrop.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBackdrop, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaBackdrop.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaBackdrop, selector: "vega-backdrop", inputs: { color: "color", duration: "duration", visible: "visible" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaBackdrop = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['color', 'duration', 'visible']
+    })
+], VegaBackdrop);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBackdrop, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-backdrop',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['color', 'duration', 'visible']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaBanner = class VegaBanner {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClose', 'close']);
+    }
+};
+VegaBanner.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBanner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaBanner.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaBanner, selector: "vega-banner", inputs: { actionButtons: "actionButtons", bannerTitle: "bannerTitle", content: "content", isOpen: "isOpen", showCloseButton: "showCloseButton", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaBanner = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['actionButtons', 'bannerTitle', 'content', 'isOpen', 'showCloseButton', 'type'],
+        methods: ['doClose']
+    })
+], VegaBanner);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBanner, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-banner',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['actionButtons', 'bannerTitle', 'content', 'isOpen', 'showCloseButton', 'type']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaBarChart = class VegaBarChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaBarChart.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBarChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaBarChart.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaBarChart, selector: "vega-bar-chart", inputs: { options: "options" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaBarChart = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['options']
+    })
+], VegaBarChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBarChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-bar-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['options']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaBox = class VegaBox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaBox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaBox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaBox, selector: "vega-box", inputs: { alignSelf: "alignSelf", backgroundColor: "backgroundColor", border: "border", borderColor: "borderColor", borderStyle: "borderStyle", corners: "corners", display: "display", flex: "flex", flexBasis: "flexBasis", flexGrow: "flexGrow", flexShrink: "flexShrink", gridArea: "gridArea", gridColumn: "gridColumn", gridRow: "gridRow", height: "height", justifySelf: "justifySelf", margin: "margin", maxHeight: "maxHeight", minHeight: "minHeight", order: "order", padding: "padding", responsiveClass: "responsiveClass", shadow: "shadow", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaBox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['alignSelf', 'backgroundColor', 'border', 'borderColor', 'borderStyle', 'corners', 'display', 'flex', 'flexBasis', 'flexGrow', 'flexShrink', 'gridArea', 'gridColumn', 'gridRow', 'height', 'justifySelf', 'margin', 'maxHeight', 'minHeight', 'order', 'padding', 'responsiveClass', 'shadow', 'width']
+    })
+], VegaBox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-box',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['alignSelf', 'backgroundColor', 'border', 'borderColor', 'borderStyle', 'corners', 'display', 'flex', 'flexBasis', 'flexGrow', 'flexShrink', 'gridArea', 'gridColumn', 'gridRow', 'height', 'justifySelf', 'margin', 'maxHeight', 'minHeight', 'order', 'padding', 'responsiveClass', 'shadow', 'width']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaBreadcrumb = class VegaBreadcrumb {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaBreadcrumb.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBreadcrumb, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaBreadcrumb.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaBreadcrumb, selector: "vega-breadcrumb", inputs: { items: "items", maxItems: "maxItems" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaBreadcrumb = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['items', 'maxItems']
+    })
+], VegaBreadcrumb);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaBreadcrumb, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-breadcrumb',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['items', 'maxItems']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaButton = class VegaButton {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaButton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaButton, selector: "vega-button", inputs: { block: "block", danger: "danger", disabled: "disabled", icon: "icon", iconAlign: "iconAlign", label: "label", size: "size", type: "type", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaButton = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['block', 'danger', 'disabled', 'icon', 'iconAlign', 'label', 'size', 'type', 'variant']
+    })
+], VegaButton);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['block', 'danger', 'disabled', 'icon', 'iconAlign', 'label', 'size', 'type', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaButtonCircle = class VegaButtonCircle {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaButtonCircle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonCircle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaButtonCircle.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaButtonCircle, selector: "vega-button-circle", inputs: { danger: "danger", disabled: "disabled", icon: "icon", iconColor: "iconColor", label: "label", showTooltip: "showTooltip", size: "size", tooltip: "tooltip", type: "type", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaButtonCircle = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['danger', 'disabled', 'icon', 'iconColor', 'label', 'showTooltip', 'size', 'tooltip', 'type', 'variant']
+    })
+], VegaButtonCircle);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonCircle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-button-circle',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['danger', 'disabled', 'icon', 'iconColor', 'label', 'showTooltip', 'size', 'tooltip', 'type', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaButtonGroup = class VegaButtonGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaButtonGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaButtonGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaButtonGroup, selector: "vega-button-group", inputs: { iconAlign: "iconAlign", size: "size", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaButtonGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['iconAlign', 'size', 'variant']
+    })
+], VegaButtonGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-button-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['iconAlign', 'size', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaButtonGroupItem = class VegaButtonGroupItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaButtonGroupItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonGroupItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaButtonGroupItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaButtonGroupItem, selector: "vega-button-group-item", inputs: { dropdownProps: "dropdownProps", dropdownSource: "dropdownSource", icon: "icon", iconOnly: "iconOnly", itemKey: "itemKey", label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaButtonGroupItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['dropdownProps', 'dropdownSource', 'icon', 'iconOnly', 'itemKey', 'label']
+    })
+], VegaButtonGroupItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonGroupItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-button-group-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['dropdownProps', 'dropdownSource', 'icon', 'iconOnly', 'itemKey', 'label']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaButtonLink = class VegaButtonLink {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaButtonLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonLink, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaButtonLink.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaButtonLink, selector: "vega-button-link", inputs: { danger: "danger", disabled: "disabled", eventful: "eventful", icon: "icon", iconAlign: "iconAlign", iconType: "iconType", label: "label", link: "link", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaButtonLink = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['danger', 'disabled', 'eventful', 'icon', 'iconAlign', 'iconType', 'label', 'link', 'size']
+    })
+], VegaButtonLink);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaButtonLink, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-button-link',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['danger', 'disabled', 'eventful', 'icon', 'iconAlign', 'iconType', 'label', 'link', 'size']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaCard = class VegaCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaCard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaCard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaCard, selector: "vega-card", inputs: { backgroundColor: "backgroundColor", margin: "margin", padding: "padding", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['backgroundColor', 'margin', 'padding', 'variant']
+    })
+], VegaCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['backgroundColor', 'margin', 'padding', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaCarousel = class VegaCarousel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaPageUpdate', 'pageUpdate']);
+    }
+};
+VegaCarousel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCarousel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaCarousel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaCarousel, selector: "vega-carousel", inputs: { canSwipe: "canSwipe", itemsPerPage: "itemsPerPage", perPage: "perPage", showSlider: "showSlider", spacing: "spacing" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaCarousel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['canSwipe', 'itemsPerPage', 'perPage', 'showSlider', 'spacing'],
+        methods: ['nextPage', 'prevPage', 'goToPage']
+    })
+], VegaCarousel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCarousel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-carousel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['canSwipe', 'itemsPerPage', 'perPage', 'showSlider', 'spacing']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaCheckbox = class VegaCheckbox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaCheckbox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaCheckbox, selector: "vega-checkbox", inputs: { checked: "checked", disabled: "disabled", identifier: "identifier", isValid: "isValid", required: "required", size: "size", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaCheckbox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['checked', 'disabled', 'identifier', 'isValid', 'required', 'size', 'value'],
+        methods: ['setValue']
+    })
+], VegaCheckbox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'disabled', 'identifier', 'isValid', 'required', 'size', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaCheckboxGroup = class VegaCheckboxGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaCheckboxGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCheckboxGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaCheckboxGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaCheckboxGroup, selector: "vega-checkbox-group", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", required: "required", validationRules: "validationRules", value: "value", vegaFlexProp: "vegaFlexProp" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaCheckboxGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'required', 'validationRules', 'value', 'vegaFlexProp']
+    })
+], VegaCheckboxGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCheckboxGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-checkbox-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'required', 'validationRules', 'value', 'vegaFlexProp']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaChip = class VegaChip {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClose', 'close', 'vegaClick', 'click']);
+    }
+};
+VegaChip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaChip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaChip.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaChip, selector: "vega-chip", inputs: { bgColor: "bgColor", chipType: "chipType", clickable: "clickable", icon: "icon", iconAlign: "iconAlign", showCloseIcon: "showCloseIcon", size: "size", statusColor: "statusColor", text: "text", textColor: "textColor", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaChip = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['bgColor', 'chipType', 'clickable', 'icon', 'iconAlign', 'showCloseIcon', 'size', 'statusColor', 'text', 'textColor', 'variant']
+    })
+], VegaChip);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaChip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-chip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['bgColor', 'chipType', 'clickable', 'icon', 'iconAlign', 'showCloseIcon', 'size', 'statusColor', 'text', 'textColor', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaColorPicker = class VegaColorPicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaColorPicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaColorPicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaColorPicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaColorPicker, selector: "vega-color-picker", inputs: { autoValidation: "autoValidation", colors: "colors", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", required: "required", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaColorPicker = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'colors', 'disabled', 'hint', 'isValid', 'label', 'required', 'validationRules', 'value']
+    })
+], VegaColorPicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaColorPicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-color-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'colors', 'disabled', 'hint', 'isValid', 'label', 'required', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaComboBox = class VegaComboBox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaCreate', 'create', 'vegaSearch', 'search']);
+    }
+};
+VegaComboBox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComboBox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaComboBox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaComboBox, selector: "vega-combo-box", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", placeholder: "placeholder", required: "required", size: "size", source: "source", useDefaultFilter: "useDefaultFilter", validationRules: "validationRules", value: "value", vegaDropdownProps: "vegaDropdownProps" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaComboBox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'placeholder', 'required', 'size', 'source', 'useDefaultFilter', 'validationRules', 'value', 'vegaDropdownProps'],
+        methods: ['close', 'open']
+    })
+], VegaComboBox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComboBox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-combo-box',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'placeholder', 'required', 'size', 'source', 'useDefaultFilter', 'validationRules', 'value', 'vegaDropdownProps']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaCounterBadge = class VegaCounterBadge {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaCounterBadge.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCounterBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaCounterBadge.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaCounterBadge, selector: "vega-counter-badge", inputs: { color: "color", count: "count", dot: "dot", offset: "offset" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaCounterBadge = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['color', 'count', 'dot', 'offset']
+    })
+], VegaCounterBadge);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaCounterBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-counter-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['color', 'count', 'dot', 'offset']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDatePicker = class VegaDatePicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaDatePicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDatePicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDatePicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDatePicker, selector: "vega-date-picker", inputs: { allowRepick: "allowRepick", autoValidation: "autoValidation", clearButton: "clearButton", disabled: "disabled", dropdownConfig: "dropdownConfig", format: "format", isValid: "isValid", label: "label", maxDate: "maxDate", minDate: "minDate", mode: "mode", placeholder: "placeholder", readOnly: "readOnly", required: "required", size: "size", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDatePicker = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['allowRepick', 'autoValidation', 'clearButton', 'disabled', 'dropdownConfig', 'format', 'isValid', 'label', 'maxDate', 'minDate', 'mode', 'placeholder', 'readOnly', 'required', 'size', 'validationRules', 'value'],
+        methods: ['doClose', 'doOpen']
+    })
+], VegaDatePicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDatePicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-date-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['allowRepick', 'autoValidation', 'clearButton', 'disabled', 'dropdownConfig', 'format', 'isValid', 'label', 'maxDate', 'minDate', 'mode', 'placeholder', 'readOnly', 'required', 'size', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDatePickerCalendar = class VegaDatePickerCalendar {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaDatePickerCalendar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDatePickerCalendar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDatePickerCalendar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDatePickerCalendar, selector: "vega-date-picker-calendar", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDatePickerCalendar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaDatePickerCalendar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDatePickerCalendar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-date-picker-calendar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDialog = class VegaDialog {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaDialog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDialog, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDialog.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDialog, selector: "vega-dialog", inputs: { cancelButton: "cancelButton", content: "content", dialogTitle: "dialogTitle", handleCancel: "handleCancel", handleOk: "handleOk", modalProps: "modalProps", okButton: "okButton", showCancel: "showCancel", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDialog = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['cancelButton', 'content', 'dialogTitle', 'handleCancel', 'handleOk', 'modalProps', 'okButton', 'showCancel', 'type']
+    })
+], VegaDialog);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDialog, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-dialog',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['cancelButton', 'content', 'dialogTitle', 'handleCancel', 'handleOk', 'modalProps', 'okButton', 'showCancel', 'type']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDivider = class VegaDivider {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaDivider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDivider.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDivider, selector: "vega-divider", inputs: { direction: "direction", margin: "margin", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDivider = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['direction', 'margin', 'variant']
+    })
+], VegaDivider);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['direction', 'margin', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDropdown = class VegaDropdown {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaDropdownClick', 'dropdownClick', 'vegaShow', 'dropdownShow', 'vegaHide', 'dropdownHide', 'vegaCreate', 'create', 'vegaSearch', 'dropdownSearch']);
+    }
+};
+VegaDropdown.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDropdown.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDropdown, selector: "vega-dropdown", inputs: { alignment: "alignment", caseSensitive: "caseSensitive", dynamicOption: "dynamicOption", isLazyLoading: "isLazyLoading", isLoading: "isLoading", itemDisplayRule: "itemDisplayRule", matchContainerHeight: "matchContainerHeight", matchTargetWidth: "matchTargetWidth", maxHeight: "maxHeight", maxWidth: "maxWidth", minWidth: "minWidth", placement: "placement", positionRelativeTo: "positionRelativeTo", prefixIconSlot: "prefixIconSlot", searchable: "searchable", selectType: "selectType", selectedSourceKey: "selectedSourceKey", size: "size", source: "source", translocation: "translocation", trigger: "trigger", useDefaultFilter: "useDefaultFilter" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDropdown = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['alignment', 'caseSensitive', 'dynamicOption', 'isLazyLoading', 'isLoading', 'itemDisplayRule', 'matchContainerHeight', 'matchTargetWidth', 'maxHeight', 'maxWidth', 'minWidth', 'placement', 'positionRelativeTo', 'prefixIconSlot', 'searchable', 'selectType', 'selectedSourceKey', 'size', 'source', 'translocation', 'trigger', 'useDefaultFilter'],
+        methods: ['show', 'hide', 'search', 'clearSelection', 'getSelection', 'setSelection']
+    })
+], VegaDropdown);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-dropdown',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['alignment', 'caseSensitive', 'dynamicOption', 'isLazyLoading', 'isLoading', 'itemDisplayRule', 'matchContainerHeight', 'matchTargetWidth', 'maxHeight', 'maxWidth', 'minWidth', 'placement', 'positionRelativeTo', 'prefixIconSlot', 'searchable', 'selectType', 'selectedSourceKey', 'size', 'source', 'translocation', 'trigger', 'useDefaultFilter']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDropdownContentBox = class VegaDropdownContentBox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaDropdownContentBox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownContentBox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDropdownContentBox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDropdownContentBox, selector: "vega-dropdown-content-box", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDropdownContentBox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaDropdownContentBox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownContentBox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-dropdown-content-box',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDropdownGroup = class VegaDropdownGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaDropdownGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDropdownGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDropdownGroup, selector: "vega-dropdown-group", inputs: { divide: "divide", label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDropdownGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['divide', 'label']
+    })
+], VegaDropdownGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-dropdown-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['divide', 'label']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaDropdownItem = class VegaDropdownItem {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaDropdownItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaDropdownItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaDropdownItem, selector: "vega-dropdown-item", inputs: { count: "count", disabled: "disabled", height: "height", itemKey: "itemKey", label: "label", prefixIcon: "prefixIcon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaDropdownItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['count', 'disabled', 'height', 'itemKey', 'label', 'prefixIcon']
+    })
+], VegaDropdownItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaDropdownItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-dropdown-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['count', 'disabled', 'height', 'itemKey', 'label', 'prefixIcon']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaFieldError = class VegaFieldError {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaFieldError.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFieldError, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaFieldError.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaFieldError, selector: "vega-field-error", inputs: { message: "message" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaFieldError = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['message']
+    })
+], VegaFieldError);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFieldError, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-field-error',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['message']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaFieldLabel = class VegaFieldLabel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick']);
+    }
+};
+VegaFieldLabel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFieldLabel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaFieldLabel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaFieldLabel, selector: "vega-field-label", inputs: { disabled: "disabled", isFieldRequired: "isFieldRequired", label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaFieldLabel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['disabled', 'isFieldRequired', 'label']
+    })
+], VegaFieldLabel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFieldLabel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-field-label',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'isFieldRequired', 'label']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaFlex = class VegaFlex {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaFlex.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFlex, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaFlex.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaFlex, selector: "vega-flex", inputs: { alignItems: "alignItems", breakpoint: "breakpoint", direction: "direction", flexWrap: "flexWrap", gap: "gap", justifyContent: "justifyContent", margin: "margin", useNativeFlex: "useNativeFlex" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaFlex = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['alignItems', 'breakpoint', 'direction', 'flexWrap', 'gap', 'justifyContent', 'margin', 'useNativeFlex']
+    })
+], VegaFlex);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFlex, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-flex',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['alignItems', 'breakpoint', 'direction', 'flexWrap', 'gap', 'justifyContent', 'margin', 'useNativeFlex']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaFont = class VegaFont {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaFont.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFont, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaFont.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaFont, selector: "vega-font", inputs: { as: "as", color: "color", disableResponsive: "disableResponsive", textAlign: "textAlign", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaFont = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['as', 'color', 'disableResponsive', 'textAlign', 'variant']
+    })
+], VegaFont);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaFont, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-font',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['as', 'color', 'disableResponsive', 'textAlign', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaForm = class VegaForm {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaValidate', 'validate', 'vegaFormSubmit', 'formSubmit', 'vegaFormReset', 'formReset']);
+    }
+};
+VegaForm.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaForm, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaForm.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaForm, selector: "vega-form", inputs: { isTouched: "isTouched", isValid: "isValid" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaForm = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['isTouched', 'isValid'],
+        methods: ['valid', 'getValue', 'setValue', 'reset']
+    })
+], VegaForm);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaForm, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-form',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isTouched', 'isValid']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaGrid = class VegaGrid {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaGrid.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaGrid, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaGrid.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaGrid, selector: "vega-grid", inputs: { column: "column", gap: "gap", row: "row" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaGrid = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['column', 'gap', 'row']
+    })
+], VegaGrid);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaGrid, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-grid',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['column', 'gap', 'row']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaIcon = class VegaIcon {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaIcon.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaIcon, selector: "vega-icon", inputs: { color: "color", icon: "icon", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaIcon = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['color', 'icon', 'size']
+    })
+], VegaIcon);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaIcon, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-icon',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['color', 'icon', 'size']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaImageUploader = class VegaImageUploader {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaRemove', 'remove', 'vegaCancel', 'cancel']);
+    }
+};
+VegaImageUploader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaImageUploader, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaImageUploader.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaImageUploader, selector: "vega-image-uploader", inputs: { accept: "accept", actionSubTitle: "actionSubTitle", actionTitle: "actionTitle", autoValidation: "autoValidation", disabled: "disabled", height: "height", hint: "hint", isValid: "isValid", label: "label", required: "required", showPreviewButton: "showPreviewButton", showRemoveButton: "showRemoveButton", showReplaceButton: "showReplaceButton", status: "status", validationRules: "validationRules", value: "value", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaImageUploader = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['accept', 'actionSubTitle', 'actionTitle', 'autoValidation', 'disabled', 'height', 'hint', 'isValid', 'label', 'required', 'showPreviewButton', 'showRemoveButton', 'showReplaceButton', 'status', 'validationRules', 'value', 'width'],
+        methods: ['getContentURL']
+    })
+], VegaImageUploader);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaImageUploader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-image-uploader',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['accept', 'actionSubTitle', 'actionTitle', 'autoValidation', 'disabled', 'height', 'hint', 'isValid', 'label', 'required', 'showPreviewButton', 'showRemoveButton', 'showReplaceButton', 'status', 'validationRules', 'value', 'width']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaInput = class VegaInput {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaBlur', 'blur', 'vegaFocus', 'focus']);
+    }
+};
+VegaInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaInput.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaInput, selector: "vega-input", inputs: { autoValidation: "autoValidation", autocomplete: "autocomplete", disableCopyPaste: "disableCopyPaste", disabled: "disabled", email: "email", hint: "hint", isValid: "isValid", label: "label", maskConfig: "maskConfig", max: "max", maxLength: "maxLength", min: "min", minLength: "minLength", placeholder: "placeholder", prefixIcon: "prefixIcon", required: "required", showClearIcon: "showClearIcon", size: "size", type: "type", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaInput = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'autocomplete', 'disableCopyPaste', 'disabled', 'email', 'hint', 'isValid', 'label', 'maskConfig', 'max', 'maxLength', 'min', 'minLength', 'placeholder', 'prefixIcon', 'required', 'showClearIcon', 'size', 'type', 'validationRules', 'value'],
+        methods: ['doFocus', 'doBlur']
+    })
+], VegaInput);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-input',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'autocomplete', 'disableCopyPaste', 'disabled', 'email', 'hint', 'isValid', 'label', 'maskConfig', 'max', 'maxLength', 'min', 'minLength', 'placeholder', 'prefixIcon', 'required', 'showClearIcon', 'size', 'type', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaInputCreditCard = class VegaInputCreditCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaBlur', 'blur', 'vegaFocus', 'focus']);
+    }
+};
+VegaInputCreditCard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputCreditCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaInputCreditCard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaInputCreditCard, selector: "vega-input-credit-card", inputs: { autoValidation: "autoValidation", disabled: "disabled", hideCardNumberOnBlur: "hideCardNumberOnBlur", hint: "hint", isValid: "isValid", label: "label", placeholder: "placeholder", required: "required", size: "size", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaInputCreditCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hideCardNumberOnBlur', 'hint', 'isValid', 'label', 'placeholder', 'required', 'size', 'validationRules', 'value']
+    })
+], VegaInputCreditCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputCreditCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-input-credit-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hideCardNumberOnBlur', 'hint', 'isValid', 'label', 'placeholder', 'required', 'size', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaInputRange = class VegaInputRange {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaInputRange.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputRange, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaInputRange.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaInputRange, selector: "vega-input-range", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", max: "max", min: "min", placeholder: "placeholder", prefixIcon: "prefixIcon", required: "required", showClearIcon: "showClearIcon", size: "size", stack: "stack", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaInputRange = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'max', 'min', 'placeholder', 'prefixIcon', 'required', 'showClearIcon', 'size', 'stack', 'validationRules', 'value']
+    })
+], VegaInputRange);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputRange, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-input-range',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'max', 'min', 'placeholder', 'prefixIcon', 'required', 'showClearIcon', 'size', 'stack', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaInputSelect = class VegaInputSelect {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaSearch', 'search']);
+    }
+};
+VegaInputSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaInputSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaInputSelect, selector: "vega-input-select", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", placeholder: "placeholder", prefixIcon: "prefixIcon", required: "required", selectType: "selectType", selectedLabel: "selectedLabel", size: "size", source: "source", sourceLazyLoadCallback: "sourceLazyLoadCallback", validationRules: "validationRules", value: "value", vegaDropdownProps: "vegaDropdownProps" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaInputSelect = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'placeholder', 'prefixIcon', 'required', 'selectType', 'selectedLabel', 'size', 'source', 'sourceLazyLoadCallback', 'validationRules', 'value', 'vegaDropdownProps'],
+        methods: ['doClose', 'doOpen', 'doChange']
+    })
+], VegaInputSelect);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaInputSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-input-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'placeholder', 'prefixIcon', 'required', 'selectType', 'selectedLabel', 'size', 'source', 'sourceLazyLoadCallback', 'validationRules', 'value', 'vegaDropdownProps']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaItemToggle = class VegaItemToggle {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaToggleStatus', 'toggleStatus']);
+    }
+};
+VegaItemToggle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaItemToggle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaItemToggle.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaItemToggle, selector: "vega-item-toggle", inputs: { isToggled: "isToggled", itemToggleStatusMap: "itemToggleStatusMap", statusMap: "statusMap" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaItemToggle = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['isToggled', 'itemToggleStatusMap', 'statusMap']
+    })
+], VegaItemToggle);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaItemToggle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-item-toggle',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isToggled', 'itemToggleStatusMap', 'statusMap']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLeftNav = class VegaLeftNav {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaStateUpdate', 'stateUpdate']);
+    }
+};
+VegaLeftNav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNav, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLeftNav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLeftNav, selector: "vega-left-nav", inputs: { autoCollapseOnOverlay: "autoCollapseOnOverlay", footnote: "footnote", headerConfig: "headerConfig", open: "open", showAsOverlay: "showAsOverlay", source: "source" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLeftNav = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoCollapseOnOverlay', 'footnote', 'headerConfig', 'open', 'showAsOverlay', 'source'],
+        methods: ['toggle']
+    })
+], VegaLeftNav);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNav, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-left-nav',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoCollapseOnOverlay', 'footnote', 'headerConfig', 'open', 'showAsOverlay', 'source']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLeftNavGroup = class VegaLeftNavGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaGroupClick', 'groupClick']);
+    }
+};
+VegaLeftNavGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLeftNavGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLeftNavGroup, selector: "vega-left-nav-group", inputs: { icon: "icon", label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLeftNavGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['icon', 'label']
+    })
+], VegaLeftNavGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-left-nav-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['icon', 'label']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLeftNavLink = class VegaLeftNavLink {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaMenuClick', 'menuClick']);
+    }
+};
+VegaLeftNavLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavLink, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLeftNavLink.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLeftNavLink, selector: "vega-left-nav-link", inputs: { counterBadge: "counterBadge", icon: "icon", selected: "selected", url: "url" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLeftNavLink = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['counterBadge', 'icon', 'selected', 'url']
+    })
+], VegaLeftNavLink);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavLink, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-left-nav-link',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['counterBadge', 'icon', 'selected', 'url']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLeftNavSection = class VegaLeftNavSection {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaActionClick', 'actionClick']);
+    }
+};
+VegaLeftNavSection.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavSection, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLeftNavSection.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLeftNavSection, selector: "vega-left-nav-section", inputs: { sectionHeader: "sectionHeader" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLeftNavSection = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['sectionHeader']
+    })
+], VegaLeftNavSection);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLeftNavSection, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-left-nav-section',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['sectionHeader']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLineChart = class VegaLineChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaLineChart.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLineChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLineChart.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLineChart, selector: "vega-line-chart", inputs: { options: "options" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLineChart = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['options'],
+        methods: ['reRender']
+    })
+], VegaLineChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLineChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-line-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['options']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLoaderWrapper = class VegaLoaderWrapper {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaLoaderWrapper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLoaderWrapper, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLoaderWrapper.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLoaderWrapper, selector: "vega-loader-wrapper", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLoaderWrapper = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaLoaderWrapper);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLoaderWrapper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-loader-wrapper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaLoadingIndicator = class VegaLoadingIndicator {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaLoadingIndicator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLoadingIndicator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaLoadingIndicator.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaLoadingIndicator, selector: "vega-loading-indicator", inputs: { hint: "hint", label: "label", mode: "mode", percent: "percent", shape: "shape", size: "size", status: "status" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaLoadingIndicator = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['hint', 'label', 'mode', 'percent', 'shape', 'size', 'status']
+    })
+], VegaLoadingIndicator);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaLoadingIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-loading-indicator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['hint', 'label', 'mode', 'percent', 'shape', 'size', 'status']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaModal = class VegaModal {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClose', 'close', 'vegaOpen', 'modalOpen']);
+    }
+};
+VegaModal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaModal, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaModal.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaModal, selector: "vega-modal", inputs: { animation: "animation", backdrop: "backdrop", backdropColor: "backdropColor", contentMaxHeight: "contentMaxHeight", handleClose: "handleClose", isVerticallyCenter: "isVerticallyCenter", isVerticallyCentered: "isVerticallyCentered", modalTitle: "modalTitle", open: "open", padding: "padding", showCloseButton: "showCloseButton", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaModal = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['animation', 'backdrop', 'backdropColor', 'contentMaxHeight', 'handleClose', 'isVerticallyCenter', 'isVerticallyCentered', 'modalTitle', 'open', 'padding', 'showCloseButton', 'size'],
+        methods: ['modal']
+    })
+], VegaModal);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaModal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-modal',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['animation', 'backdrop', 'backdropColor', 'contentMaxHeight', 'handleClose', 'isVerticallyCenter', 'isVerticallyCentered', 'modalTitle', 'open', 'padding', 'showCloseButton', 'size']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaNavCard = class VegaNavCard {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaNavCard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaNavCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaNavCard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaNavCard, selector: "vega-nav-card", inputs: { maxHeight: "maxHeight", source: "source" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaNavCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['maxHeight', 'source']
+    })
+], VegaNavCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaNavCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-nav-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['maxHeight', 'source']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPageNotification = class VegaPageNotification {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaPageNotification.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPageNotification, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPageNotification.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPageNotification, selector: "vega-page-notification", inputs: { actionButtons: "actionButtons", duration: "duration", message: "message", notificationTitle: "notificationTitle", showCloseButton: "showCloseButton", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPageNotification = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['actionButtons', 'duration', 'message', 'notificationTitle', 'showCloseButton', 'type'],
+        methods: ['close']
+    })
+], VegaPageNotification);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPageNotification, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-page-notification',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['actionButtons', 'duration', 'message', 'notificationTitle', 'showCloseButton', 'type']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPageNotificationList = class VegaPageNotificationList {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaPageNotificationList.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPageNotificationList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPageNotificationList.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPageNotificationList, selector: "vega-page-notification-list", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPageNotificationList = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaPageNotificationList);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPageNotificationList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-page-notification-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPagination = class VegaPagination {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaPageSizeChange', 'pageSizeChange']);
+    }
+};
+VegaPagination.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPagination, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPagination.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPagination, selector: "vega-pagination", inputs: { current: "current", extensions: "extensions", pageSize: "pageSize", pageSizeSelectorOptions: "pageSizeSelectorOptions", total: "total" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPagination = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['current', 'extensions', 'pageSize', 'pageSizeSelectorOptions', 'total']
+    })
+], VegaPagination);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPagination, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-pagination',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['current', 'extensions', 'pageSize', 'pageSizeSelectorOptions', 'total']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPieChart = class VegaPieChart {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaPieChart.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPieChart, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPieChart.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPieChart, selector: "vega-pie-chart", inputs: { options: "options" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPieChart = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['options'],
+        methods: ['reRender']
+    })
+], VegaPieChart);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPieChart, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-pie-chart',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['options']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPopover = class VegaPopover {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaPopoverShow', 'popoverShow', 'vegaPopoverHide', 'popoverHide']);
+    }
+};
+VegaPopover.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPopover, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPopover.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPopover, selector: "vega-popover", inputs: { alignment: "alignment", placement: "placement", positionRelativeTo: "positionRelativeTo", showArrow: "showArrow", size: "size", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPopover = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['alignment', 'placement', 'positionRelativeTo', 'showArrow', 'size', 'trigger'],
+        methods: ['show', 'hide']
+    })
+], VegaPopover);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPopover, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-popover',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['alignment', 'placement', 'positionRelativeTo', 'showArrow', 'size', 'trigger']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaPopoverContentBox = class VegaPopoverContentBox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaPopoverContentBox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPopoverContentBox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaPopoverContentBox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaPopoverContentBox, selector: "vega-popover-content-box", inputs: { showArrow: "showArrow" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaPopoverContentBox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['showArrow']
+    })
+], VegaPopoverContentBox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaPopoverContentBox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-popover-content-box',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['showArrow']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaProgressTracker = class VegaProgressTracker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaCurrentStepUpdate', 'currentStepUpdate']);
+    }
+};
+VegaProgressTracker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaProgressTracker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaProgressTracker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaProgressTracker, selector: "vega-progress-tracker", inputs: { canClickStep: "canClickStep", completedStepArray: "completedStepArray", completedSteps: "completedSteps", current: "current", direction: "direction", steps: "steps" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaProgressTracker = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['canClickStep', 'completedStepArray', 'completedSteps', 'current', 'direction', 'steps'],
+        methods: ['nextStep', 'prevStep', 'setCurrent', 'getCurrent']
+    })
+], VegaProgressTracker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaProgressTracker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-progress-tracker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['canClickStep', 'completedStepArray', 'completedSteps', 'current', 'direction', 'steps']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaRadio = class VegaRadio {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaFocus', 'focus', 'vegaBlur', 'blur', 'vegaChange', 'change']);
+    }
+};
+VegaRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaRadio.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaRadio, selector: "vega-radio", inputs: { checked: "checked", disabled: "disabled", name: "name", size: "size", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaRadio = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['checked', 'disabled', 'name', 'size', 'value']
+    })
+], VegaRadio);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaRadio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-radio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'disabled', 'name', 'size', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaRadioGroup = class VegaRadioGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaRadioGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaRadioGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaRadioGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaRadioGroup, selector: "vega-radio-group", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", name: "name", required: "required", validationRules: "validationRules", value: "value", vegaFlexProp: "vegaFlexProp" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaRadioGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'name', 'required', 'validationRules', 'value', 'vegaFlexProp']
+    })
+], VegaRadioGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaRadioGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-radio-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'name', 'required', 'validationRules', 'value', 'vegaFlexProp']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaSectionTitle = class VegaSectionTitle {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaSectionTitle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSectionTitle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaSectionTitle.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaSectionTitle, selector: "vega-section-title", inputs: { description: "description", icon: "icon", iconAlign: "iconAlign", titleText: "titleText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaSectionTitle = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['description', 'icon', 'iconAlign', 'titleText']
+    })
+], VegaSectionTitle);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSectionTitle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-section-title',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['description', 'icon', 'iconAlign', 'titleText']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaSegmentControl = class VegaSegmentControl {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaSegmentControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSegmentControl, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaSegmentControl.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaSegmentControl, selector: "vega-segment-control", inputs: { block: "block", segments: "segments", selected: "selected", size: "size", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaSegmentControl = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['block', 'segments', 'selected', 'size', 'variant']
+    })
+], VegaSegmentControl);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSegmentControl, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-segment-control',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['block', 'segments', 'selected', 'size', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaSelectionTile = class VegaSelectionTile {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaSelectionTile.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSelectionTile, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaSelectionTile.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaSelectionTile, selector: "vega-selection-tile", inputs: { checked: "checked", disabled: "disabled", note: "note", prefixIcon: "prefixIcon", selectType: "selectType", titleText: "titleText", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaSelectionTile = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['checked', 'disabled', 'note', 'prefixIcon', 'selectType', 'titleText', 'value']
+    })
+], VegaSelectionTile);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSelectionTile, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-selection-tile',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'disabled', 'note', 'prefixIcon', 'selectType', 'titleText', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaSelectionTileGroup = class VegaSelectionTileGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaSelectionTileGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSelectionTileGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaSelectionTileGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaSelectionTileGroup, selector: "vega-selection-tile-group", inputs: { disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", layout: "layout", required: "required", selectType: "selectType", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaSelectionTileGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['disabled', 'hint', 'isValid', 'label', 'layout', 'required', 'selectType', 'validationRules', 'value']
+    })
+], VegaSelectionTileGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSelectionTileGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-selection-tile-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'hint', 'isValid', 'label', 'layout', 'required', 'selectType', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaSlotContainer = class VegaSlotContainer {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaSlotContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSlotContainer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaSlotContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaSlotContainer, selector: "vega-slot-container", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaSlotContainer = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaSlotContainer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaSlotContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-slot-container',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaStepper = class VegaStepper {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaStepper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaStepper, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaStepper.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaStepper, selector: "vega-stepper", inputs: { autoValidation: "autoValidation", buttonVariant: "buttonVariant", disabled: "disabled", inputDisabled: "inputDisabled", isValid: "isValid", label: "label", max: "max", min: "min", stepperId: "stepperId", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaStepper = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'buttonVariant', 'disabled', 'inputDisabled', 'isValid', 'label', 'max', 'min', 'stepperId', 'value']
+    })
+], VegaStepper);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaStepper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-stepper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'buttonVariant', 'disabled', 'inputDisabled', 'isValid', 'label', 'max', 'min', 'stepperId', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTabGroup = class VegaTabGroup {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaTabGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTabGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTabGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTabGroup, selector: "vega-tab-group", inputs: { gap: "gap", positionRelativeTo: "positionRelativeTo", selectedTabDataTarget: "selectedTabDataTarget", showCloseButton: "showCloseButton", tabItems: "tabItems", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTabGroup = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['gap', 'positionRelativeTo', 'selectedTabDataTarget', 'showCloseButton', 'tabItems', 'variant']
+    })
+], VegaTabGroup);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTabGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-tab-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['gap', 'positionRelativeTo', 'selectedTabDataTarget', 'showCloseButton', 'tabItems', 'variant']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTabGroupPanel = class VegaTabGroupPanel {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTabGroupPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTabGroupPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTabGroupPanel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTabGroupPanel, selector: "vega-tab-group-panel", inputs: { isActive: "isActive" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTabGroupPanel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['isActive']
+    })
+], VegaTabGroupPanel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTabGroupPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-tab-group-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isActive']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTable = class VegaTable {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaRowClick', 'rowClick', 'vegaSelectChange', 'selectChange', 'vegaSelectAllChange', 'selectAllChange']);
+    }
+};
+VegaTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTable, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTable, selector: "vega-table", inputs: { columnDivider: "columnDivider", columns: "columns", dataSource: "dataSource", density: "density", emptyDescription: "emptyDescription", paddingX: "paddingX", pagination: "pagination", rowClickable: "rowClickable", rowDivider: "rowDivider", rowExpandable: "rowExpandable", rowKey: "rowKey", rowSelection: "rowSelection", scrollConfig: "scrollConfig", showHeader: "showHeader", striped: "striped" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTable = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['columnDivider', 'columns', 'dataSource', 'density', 'emptyDescription', 'paddingX', 'pagination', 'rowClickable', 'rowDivider', 'rowExpandable', 'rowKey', 'rowSelection', 'scrollConfig', 'showHeader', 'striped'],
+        methods: ['openExpandRow', 'closeExpandRow', 'closeAllExpandRow', 'toggleExpandRow', 'clearSelection', 'getSelection', 'setSelection', 'startRowEditMode', 'stopRowEditMode', 'stopAllRowEditMode', 'getRowData', 'getRowsData', 'getFormRef', 'addNewRow', 'saveEditRow', 'saveAllEditRows', 'getEditingRowsKey', 'removeRow']
+    })
+], VegaTable);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTable, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['columnDivider', 'columns', 'dataSource', 'density', 'emptyDescription', 'paddingX', 'pagination', 'rowClickable', 'rowDivider', 'rowExpandable', 'rowKey', 'rowSelection', 'scrollConfig', 'showHeader', 'striped']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableBody = class VegaTableBody {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTableBody.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableBody, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableBody.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableBody, selector: "vega-table-body", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableBody = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaTableBody);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableBody, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-body',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableCell = class VegaTableCell {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTableCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableCell, selector: "vega-table-cell", inputs: { breakpoint: "breakpoint", overflow: "overflow", textAlign: "textAlign", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableCell = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['breakpoint', 'overflow', 'textAlign', 'width']
+    })
+], VegaTableCell);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['breakpoint', 'overflow', 'textAlign', 'width']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableExpandRow = class VegaTableExpandRow {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTableExpandRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableExpandRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableExpandRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableExpandRow, selector: "vega-table-expand-row", inputs: { rowKey: "rowKey" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableExpandRow = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['rowKey']
+    })
+], VegaTableExpandRow);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableExpandRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-expand-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['rowKey']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableHead = class VegaTableHead {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTableHead.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHead, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableHead.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableHead, selector: "vega-table-head", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableHead = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaTableHead);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHead, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-head',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableHeadCell = class VegaTableHeadCell {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaTableHeadCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHeadCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableHeadCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableHeadCell, selector: "vega-table-head-cell", inputs: { breakpoint: "breakpoint", sortOrder: "sortOrder", sorter: "sorter", textAlign: "textAlign", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableHeadCell = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['breakpoint', 'sortOrder', 'sorter', 'textAlign', 'width']
+    })
+], VegaTableHeadCell);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHeadCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-head-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['breakpoint', 'sortOrder', 'sorter', 'textAlign', 'width']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableHeadRow = class VegaTableHeadRow {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTableHeadRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHeadRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableHeadRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableHeadRow, selector: "vega-table-head-row", inputs: { hideSelectAll: "hideSelectAll", selectAllDisabled: "selectAllDisabled" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableHeadRow = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['hideSelectAll', 'selectAllDisabled']
+    })
+], VegaTableHeadRow);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableHeadRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-head-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['hideSelectAll', 'selectAllDisabled']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTableRow = class VegaTableRow {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaClick', 'click']);
+    }
+};
+VegaTableRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTableRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTableRow, selector: "vega-table-row", inputs: { rowKey: "rowKey" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTableRow = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['rowKey']
+    })
+], VegaTableRow);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTableRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-table-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['rowKey']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaText = class VegaText {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaText.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaText, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaText.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaText, selector: "vega-text", inputs: { overflow: "overflow", tooltip: "tooltip" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaText = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['overflow', 'tooltip']
+    })
+], VegaText);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaText, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-text',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['overflow', 'tooltip']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTextarea = class VegaTextarea {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change', 'vegaBlur', 'blur']);
+    }
+};
+VegaTextarea.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTextarea, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTextarea.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTextarea, selector: "vega-textarea", inputs: { autoValidation: "autoValidation", disabled: "disabled", hint: "hint", isValid: "isValid", label: "label", maxLength: "maxLength", minLength: "minLength", placeholder: "placeholder", required: "required", showCounter: "showCounter", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTextarea = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'maxLength', 'minLength', 'placeholder', 'required', 'showCounter', 'validationRules', 'value']
+    })
+], VegaTextarea);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTextarea, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-textarea',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'hint', 'isValid', 'label', 'maxLength', 'minLength', 'placeholder', 'required', 'showCounter', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTimePicker = class VegaTimePicker {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaTimePicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTimePicker, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTimePicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTimePicker, selector: "vega-time-picker", inputs: { autoValidation: "autoValidation", disabled: "disabled", increments: "increments", isValid: "isValid", label: "label", mode: "mode", placeholder: "placeholder", positionRelativeTo: "positionRelativeTo", required: "required", size: "size", timeFormat: "timeFormat", validationRules: "validationRules", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTimePicker = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['autoValidation', 'disabled', 'increments', 'isValid', 'label', 'mode', 'placeholder', 'positionRelativeTo', 'required', 'size', 'timeFormat', 'validationRules', 'value']
+    })
+], VegaTimePicker);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTimePicker, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-time-picker',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['autoValidation', 'disabled', 'increments', 'isValid', 'label', 'mode', 'placeholder', 'positionRelativeTo', 'required', 'size', 'timeFormat', 'validationRules', 'value']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTimePickerDropdown = class VegaTimePickerDropdown {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTimePickerDropdown.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTimePickerDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTimePickerDropdown.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTimePickerDropdown, selector: "vega-time-picker-dropdown", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTimePickerDropdown = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined
+    })
+], VegaTimePickerDropdown);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTimePickerDropdown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-time-picker-dropdown',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaToggleSwitch = class VegaToggleSwitch {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['vegaChange', 'change']);
+    }
+};
+VegaToggleSwitch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaToggleSwitch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaToggleSwitch.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaToggleSwitch, selector: "vega-toggle-switch", inputs: { checked: "checked", disabled: "disabled", label: "label", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaToggleSwitch = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['checked', 'disabled', 'label', 'size']
+    })
+], VegaToggleSwitch);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaToggleSwitch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-toggle-switch',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'disabled', 'label', 'size']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTooltip = class VegaTooltip {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTooltip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTooltip.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTooltip, selector: "vega-tooltip", inputs: { alignment: "alignment", content: "content", disableInteractive: "disableInteractive", maxWidth: "maxWidth", minWidth: "minWidth", placement: "placement", positionRelativeTo: "positionRelativeTo", size: "size", text: "text", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTooltip = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['alignment', 'content', 'disableInteractive', 'maxWidth', 'minWidth', 'placement', 'positionRelativeTo', 'size', 'text', 'trigger']
+    })
+], VegaTooltip);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTooltip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-tooltip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['alignment', 'content', 'disableInteractive', 'maxWidth', 'minWidth', 'placement', 'positionRelativeTo', 'size', 'text', 'trigger']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaTooltipContentBox = class VegaTooltipContentBox {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaTooltipContentBox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTooltipContentBox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaTooltipContentBox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaTooltipContentBox, selector: "vega-tooltip-content-box", inputs: { text: "text" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaTooltipContentBox = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['text']
+    })
+], VegaTooltipContentBox);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaTooltipContentBox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-tooltip-content-box',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['text']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let VegaVirtualScroll = class VegaVirtualScroll {
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+};
+VegaVirtualScroll.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaVirtualScroll, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+VegaVirtualScroll.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VegaVirtualScroll, selector: "vega-virtual-scroll", inputs: { approxItemHeight: "approxItemHeight", isLoading: "isLoading", renderItem: "renderItem", source: "source", sourceItemIdentifier: "sourceItemIdentifier", viewportMaxHeight: "viewportMaxHeight", virtualizationThreshold: "virtualizationThreshold" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+VegaVirtualScroll = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: undefined,
+        inputs: ['approxItemHeight', 'isLoading', 'renderItem', 'source', 'sourceItemIdentifier', 'viewportMaxHeight', 'virtualizationThreshold'],
+        methods: ['scrollToIndex']
+    })
+], VegaVirtualScroll);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaVirtualScroll, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vega-virtual-scroll',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['approxItemHeight', 'isLoading', 'renderItem', 'source', 'sourceItemIdentifier', 'viewportMaxHeight', 'virtualizationThreshold']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+var VegaComponents = [
+    VegaAccordion,
+    VegaAppFooter,
+    VegaAppHeaderButton,
+    VegaBackdrop,
+    VegaBanner,
+    VegaBarChart,
+    VegaBox,
+    VegaBreadcrumb,
+    VegaButton,
+    VegaButtonCircle,
+    VegaButtonGroup,
+    VegaButtonGroupItem,
+    VegaButtonLink,
+    VegaCard,
+    VegaCarousel,
+    VegaCheckbox,
+    VegaCheckboxGroup,
+    VegaChip,
+    VegaColorPicker,
+    VegaComboBox,
+    VegaCounterBadge,
+    VegaDatePicker,
+    VegaDatePickerCalendar,
+    VegaDialog,
+    VegaDivider,
+    VegaDropdown,
+    VegaDropdownContentBox,
+    VegaDropdownGroup,
+    VegaDropdownItem,
+    VegaFieldError,
+    VegaFieldLabel,
+    VegaFlex,
+    VegaFont,
+    VegaForm,
+    VegaGrid,
+    VegaIcon,
+    VegaImageUploader,
+    VegaInput,
+    VegaInputCreditCard,
+    VegaInputRange,
+    VegaInputSelect,
+    VegaItemToggle,
+    VegaLeftNav,
+    VegaLeftNavGroup,
+    VegaLeftNavLink,
+    VegaLeftNavSection,
+    VegaLineChart,
+    VegaLoaderWrapper,
+    VegaLoadingIndicator,
+    VegaModal,
+    VegaNavCard,
+    VegaPageNotification,
+    VegaPageNotificationList,
+    VegaPagination,
+    VegaPieChart,
+    VegaPopover,
+    VegaPopoverContentBox,
+    VegaProgressTracker,
+    VegaRadio,
+    VegaRadioGroup,
+    VegaSectionTitle,
+    VegaSegmentControl,
+    VegaSelectionTile,
+    VegaSelectionTileGroup,
+    VegaSlotContainer,
+    VegaStepper,
+    VegaTabGroup,
+    VegaTabGroupPanel,
+    VegaTable,
+    VegaTableBody,
+    VegaTableCell,
+    VegaTableExpandRow,
+    VegaTableHead,
+    VegaTableHeadCell,
+    VegaTableHeadRow,
+    VegaTableRow,
+    VegaText,
+    VegaTextarea,
+    VegaTimePicker,
+    VegaTimePickerDropdown,
+    VegaToggleSwitch,
+    VegaTooltip,
+    VegaTooltipContentBox,
+    VegaVirtualScroll,
+];
+
+class VegaComponentModule {
+    constructor() {
+        this.useJuggleResizeObserver();
+        VegaEnvManager.setVegaFramework(FrameworkEnum.Angular);
+        defineCustomElements(window).then();
+    }
+    useJuggleResizeObserver() {
+        if (FeatureFlag.isEnabled('VEGA_ANGULAR.USE_JUGGLE_RESIZE_OBSERVER')) {
+            Object.assign(window, {
+                'VegaResizeObserver': ResizeObserver
+            });
+        }
+    }
+}
+VegaComponentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComponentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VegaComponentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComponentModule, declarations: [VegaAccordion, VegaAppFooter, VegaAppHeaderButton, VegaBackdrop, VegaBanner, VegaBarChart, VegaBox, VegaBreadcrumb, VegaButton, VegaButtonCircle, VegaButtonGroup, VegaButtonGroupItem, VegaButtonLink, VegaCard, VegaCarousel, VegaCheckbox, VegaCheckboxGroup, VegaChip, VegaColorPicker, VegaComboBox, VegaCounterBadge, VegaDatePicker, VegaDatePickerCalendar, VegaDialog, VegaDivider, VegaDropdown, VegaDropdownContentBox, VegaDropdownGroup, VegaDropdownItem, VegaFieldError, VegaFieldLabel, VegaFlex, VegaFont, VegaForm, VegaGrid, VegaIcon, VegaImageUploader, VegaInput, VegaInputCreditCard, VegaInputRange, VegaInputSelect, VegaItemToggle, VegaLeftNav, VegaLeftNavGroup, VegaLeftNavLink, VegaLeftNavSection, VegaLineChart, VegaLoaderWrapper, VegaLoadingIndicator, VegaModal, VegaNavCard, VegaPageNotification, VegaPageNotificationList, VegaPagination, VegaPieChart, VegaPopover, VegaPopoverContentBox, VegaProgressTracker, VegaRadio, VegaRadioGroup, VegaSectionTitle, VegaSegmentControl, VegaSelectionTile, VegaSelectionTileGroup, VegaSlotContainer, VegaStepper, VegaTabGroup, VegaTabGroupPanel, VegaTable, VegaTableBody, VegaTableCell, VegaTableExpandRow, VegaTableHead, VegaTableHeadCell, VegaTableHeadRow, VegaTableRow, VegaText, VegaTextarea, VegaTimePicker, VegaTimePickerDropdown, VegaToggleSwitch, VegaTooltip, VegaTooltipContentBox, VegaVirtualScroll, TextValueAccessor, ValueAccessor], exports: [VegaAccordion, VegaAppFooter, VegaAppHeaderButton, VegaBackdrop, VegaBanner, VegaBarChart, VegaBox, VegaBreadcrumb, VegaButton, VegaButtonCircle, VegaButtonGroup, VegaButtonGroupItem, VegaButtonLink, VegaCard, VegaCarousel, VegaCheckbox, VegaCheckboxGroup, VegaChip, VegaColorPicker, VegaComboBox, VegaCounterBadge, VegaDatePicker, VegaDatePickerCalendar, VegaDialog, VegaDivider, VegaDropdown, VegaDropdownContentBox, VegaDropdownGroup, VegaDropdownItem, VegaFieldError, VegaFieldLabel, VegaFlex, VegaFont, VegaForm, VegaGrid, VegaIcon, VegaImageUploader, VegaInput, VegaInputCreditCard, VegaInputRange, VegaInputSelect, VegaItemToggle, VegaLeftNav, VegaLeftNavGroup, VegaLeftNavLink, VegaLeftNavSection, VegaLineChart, VegaLoaderWrapper, VegaLoadingIndicator, VegaModal, VegaNavCard, VegaPageNotification, VegaPageNotificationList, VegaPagination, VegaPieChart, VegaPopover, VegaPopoverContentBox, VegaProgressTracker, VegaRadio, VegaRadioGroup, VegaSectionTitle, VegaSegmentControl, VegaSelectionTile, VegaSelectionTileGroup, VegaSlotContainer, VegaStepper, VegaTabGroup, VegaTabGroupPanel, VegaTable, VegaTableBody, VegaTableCell, VegaTableExpandRow, VegaTableHead, VegaTableHeadCell, VegaTableHeadRow, VegaTableRow, VegaText, VegaTextarea, VegaTimePicker, VegaTimePickerDropdown, VegaToggleSwitch, VegaTooltip, VegaTooltipContentBox, VegaVirtualScroll, TextValueAccessor, ValueAccessor] });
+VegaComponentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComponentModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VegaComponentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...VegaComponents, TextValueAccessor, ValueAccessor],
+                    imports: [],
+                    exports: [...VegaComponents, TextValueAccessor, ValueAccessor],
+                }]
+        }], ctorParameters: function () { return []; } });
+
+/*
+ * Public API Surface of vega-angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { TextValueAccessor, ValueAccessor, VegaAccordion, VegaAppFooter, VegaAppHeaderButton, VegaBackdrop, VegaBanner, VegaBarChart, VegaBox, VegaBreadcrumb, VegaButton, VegaButtonCircle, VegaButtonGroup, VegaButtonGroupItem, VegaButtonLink, VegaCard, VegaCarousel, VegaCheckbox, VegaCheckboxGroup, VegaChip, VegaColorPicker, VegaComboBox, VegaComponentModule, VegaCounterBadge, VegaDatePicker, VegaDatePickerCalendar, VegaDialog, VegaDivider, VegaDropdown, VegaDropdownContentBox, VegaDropdownGroup, VegaDropdownItem, VegaFieldError, VegaFieldLabel, VegaFlex, VegaFont, VegaForm, VegaGrid, VegaIcon, VegaImageUploader, VegaInput, VegaInputCreditCard, VegaInputRange, VegaInputSelect, VegaItemToggle, VegaLeftNav, VegaLeftNavGroup, VegaLeftNavLink, VegaLeftNavSection, VegaLineChart, VegaLoaderWrapper, VegaLoadingIndicator, VegaModal, VegaNavCard, VegaPageNotification, VegaPageNotificationList, VegaPagination, VegaPieChart, VegaPopover, VegaPopoverContentBox, VegaProgressTracker, VegaRadio, VegaRadioGroup, VegaSectionTitle, VegaSegmentControl, VegaSelectionTile, VegaSelectionTileGroup, VegaSlotContainer, VegaStepper, VegaTabGroup, VegaTabGroupPanel, VegaTable, VegaTableBody, VegaTableCell, VegaTableExpandRow, VegaTableHead, VegaTableHeadCell, VegaTableHeadRow, VegaTableRow, VegaText, VegaTextarea, VegaTimePicker, VegaTimePickerDropdown, VegaToggleSwitch, VegaTooltip, VegaTooltipContentBox, VegaVirtualScroll };
+//# sourceMappingURL=heartlandone-vega-angular.mjs.map