@xlabs-store/angular 0.0.1

package/dist/fesm2022/xlabs-store-angular.mjs

@@ -0,0 +1,4585 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, ChangeDetectionStrategy, Component, Output, provideAppInitializer, inject, TemplateRef, Directive, Input, ChangeDetectorRef, ContentChildren, NgModule } from '@angular/core';
+import { __decorate } from 'tslib';
+import { fromEvent } from 'rxjs';
+import { defineCustomElements } from '@xlabs-store/core/loader';
+import { CommonModule } from '@angular/common';
+export { message, modal, notification } from '@xlabs-store/core';
+
+/* eslint-disable */
+/* tslint:disable */
+const proxyInputs = (Cmp, inputs) => {
+    const Prototype = Cmp.prototype;
+    inputs.forEach((item) => {
+        Object.defineProperty(Prototype, item, {
+            get() {
+                return this.el[item];
+            },
+            set(val) {
+                this.z.runOutsideAngular(() => (this.el[item] = val));
+            },
+            /**
+             * In the event that proxyInputs is called
+             * multiple times re-defining these inputs
+             * will cause an error to be thrown. As a result
+             * we set configurable: true to indicate these
+             * properties can be changed.
+             */
+            configurable: true,
+        });
+    });
+};
+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;
+}
+
+const _c0 = ["*"];
+let XAddress = class XAddress {
+    z;
+    el;
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAddress_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAddress)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAddress, selectors: [["x-address"]], inputs: { disabled: "disabled", districtsData: "districtsData", placeholderDistrict: "placeholderDistrict", placeholderProvince: "placeholderProvince", placeholderWard: "placeholderWard", provincesData: "provincesData", required: "required", value: "value", wardsData: "wardsData" }, outputs: { xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAddress_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAddress = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'districtsData', 'placeholderDistrict', 'placeholderProvince', 'placeholderWard', 'provincesData', 'required', 'value', 'wardsData'],
+        methods: ['validate']
+    })
+], XAddress);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAddress, [{
+        type: Component,
+        args: [{
+                selector: 'x-address',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabled', 'districtsData', 'placeholderDistrict', 'placeholderProvince', 'placeholderWard', 'provincesData', 'required', 'value', 'wardsData'],
+                outputs: ['xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAddress, { className: "XAddress", filePath: "lib/proxies.ts", lineNumber: 23 }); })();
+let XAffix = class XAffix {
+    z;
+    el;
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAffix_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAffix)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAffix, selectors: [["x-affix"]], inputs: { bottomOffset: "bottomOffset", target: "target", topOffset: "topOffset" }, outputs: { xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAffix_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAffix = __decorate([
+    ProxyCmp({
+        inputs: ['bottomOffset', 'target', 'topOffset']
+    })
+], XAffix);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAffix, [{
+        type: Component,
+        args: [{
+                selector: 'x-affix',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bottomOffset', 'target', 'topOffset'],
+                outputs: ['xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAffix, { className: "XAffix", filePath: "lib/proxies.ts", lineNumber: 51 }); })();
+let XAlert = class XAlert {
+    z;
+    el;
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAlert_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAlert)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAlert, selectors: [["x-alert"]], inputs: { banner: "banner", closable: "closable", description: "description", message: "message", showIcon: "showIcon", type: "type" }, outputs: { xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAlert_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAlert = __decorate([
+    ProxyCmp({
+        inputs: ['banner', 'closable', 'description', 'message', 'showIcon', 'type']
+    })
+], XAlert);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAlert, [{
+        type: Component,
+        args: [{
+                selector: 'x-alert',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['banner', 'closable', 'description', 'message', 'showIcon', 'type'],
+                outputs: ['xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAlert, { className: "XAlert", filePath: "lib/proxies.ts", lineNumber: 81 }); })();
+let XAnchor = class XAnchor {
+    z;
+    el;
+    xClick = new EventEmitter();
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAnchor_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAnchor)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAnchor, selectors: [["x-anchor"]], inputs: { affix: "affix", bounds: "bounds", getContainer: "getContainer", showInkInFixed: "showInkInFixed", targetOffset: "targetOffset", topOffset: "topOffset" }, outputs: { xClick: "xClick", xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAnchor_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAnchor = __decorate([
+    ProxyCmp({
+        inputs: ['affix', 'bounds', 'getContainer', 'showInkInFixed', 'targetOffset', 'topOffset']
+    })
+], XAnchor);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAnchor, [{
+        type: Component,
+        args: [{
+                selector: 'x-anchor',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['affix', 'bounds', 'getContainer', 'showInkInFixed', 'targetOffset', 'topOffset'],
+                outputs: ['xClick', 'xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClick: [{
+            type: Output
+        }], xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAnchor, { className: "XAnchor", filePath: "lib/proxies.ts", lineNumber: 111 }); })();
+let XAnchorLink = class XAnchorLink {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAnchorLink_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAnchorLink)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAnchorLink, selectors: [["x-anchor-link"]], inputs: { href: "href", linkTitle: "linkTitle", target: "target" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAnchorLink_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAnchorLink = __decorate([
+    ProxyCmp({
+        inputs: ['href', 'linkTitle', 'target']
+    })
+], XAnchorLink);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAnchorLink, [{
+        type: Component,
+        args: [{
+                selector: 'x-anchor-link',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['href', 'linkTitle', 'target'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAnchorLink, { className: "XAnchorLink", filePath: "lib/proxies.ts", lineNumber: 145 }); })();
+let XApp = class XApp {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XApp_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XApp)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XApp, selectors: [["x-app"]], inputs: { fixed: "fixed", iconConfig: "iconConfig", locale: "locale" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XApp_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XApp = __decorate([
+    ProxyCmp({
+        inputs: ['fixed', 'iconConfig', 'locale'],
+        methods: ['getContainer', 'setLocale']
+    })
+], XApp);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XApp, [{
+        type: Component,
+        args: [{
+                selector: 'x-app',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['fixed', 'iconConfig', 'locale'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XApp, { className: "XApp", filePath: "lib/proxies.ts", lineNumber: 169 }); })();
+let XAutoComplete = class XAutoComplete {
+    z;
+    el;
+    xBlur = new EventEmitter();
+    xChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xFocus = new EventEmitter();
+    xSelect = new EventEmitter();
+    xClear = new EventEmitter();
+    xSearch = new EventEmitter();
+    xInputKeyDown = new EventEmitter();
+    xPopupScroll = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAutoComplete_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAutoComplete)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAutoComplete, selectors: [["x-auto-complete"]], inputs: { allowClear: "allowClear", autoFocus: "autoFocus", backfill: "backfill", classNames: "classNames", defaultActiveFirstOption: "defaultActiveFirstOption", defaultOpen: "defaultOpen", defaultValue: "defaultValue", disabled: "disabled", filterOption: "filterOption", listHeight: "listHeight", notFoundContent: "notFoundContent", open: "open", options: "options", placeholder: "placeholder", placement: "placement", popupMatchSelectWidth: "popupMatchSelectWidth", prefixIcon: "prefixIcon", size: "size", status: "status", styles: "styles", suffixIcon: "suffixIcon", value: "value", variant: "variant", virtual: "virtual" }, outputs: { xBlur: "xBlur", xChange: "xChange", xOpenChange: "xOpenChange", xFocus: "xFocus", xSelect: "xSelect", xClear: "xClear", xSearch: "xSearch", xInputKeyDown: "xInputKeyDown", xPopupScroll: "xPopupScroll" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAutoComplete_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAutoComplete = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autoFocus', 'backfill', 'classNames', 'defaultActiveFirstOption', 'defaultOpen', 'defaultValue', 'disabled', 'filterOption', 'listHeight', 'notFoundContent', 'open', 'options', 'placeholder', 'placement', 'popupMatchSelectWidth', 'prefixIcon', 'size', 'status', 'styles', 'suffixIcon', 'value', 'variant', 'virtual'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XAutoComplete);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAutoComplete, [{
+        type: Component,
+        args: [{
+                selector: 'x-auto-complete',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autoFocus', 'backfill', 'classNames', 'defaultActiveFirstOption', 'defaultOpen', 'defaultValue', 'disabled', 'filterOption', 'listHeight', 'notFoundContent', 'open', 'options', 'placeholder', 'placement', 'popupMatchSelectWidth', 'prefixIcon', 'size', 'status', 'styles', 'suffixIcon', 'value', 'variant', 'virtual'],
+                outputs: ['xBlur', 'xChange', 'xOpenChange', 'xFocus', 'xSelect', 'xClear', 'xSearch', 'xInputKeyDown', 'xPopupScroll'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xBlur: [{
+            type: Output
+        }], xChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xSelect: [{
+            type: Output
+        }], xClear: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }], xInputKeyDown: [{
+            type: Output
+        }], xPopupScroll: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAutoComplete, { className: "XAutoComplete", filePath: "lib/proxies.ts", lineNumber: 194 }); })();
+let XAutoCompleteDropdownContent = class XAutoCompleteDropdownContent {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAutoCompleteDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAutoCompleteDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAutoCompleteDropdownContent, selectors: [["x-auto-complete-dropdown-content"]], inputs: { dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", setDropdownRef: "setDropdownRef" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAutoCompleteDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAutoCompleteDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['dropdownClasses', 'dropdownStyle', 'setDropdownRef']
+    })
+], XAutoCompleteDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAutoCompleteDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-auto-complete-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['dropdownClasses', 'dropdownStyle', 'setDropdownRef'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAutoCompleteDropdownContent, { className: "XAutoCompleteDropdownContent", filePath: "lib/proxies.ts", lineNumber: 269 }); })();
+let XAvatar = class XAvatar {
+    z;
+    el;
+    xError = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XAvatar_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XAvatar)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XAvatar, selectors: [["x-avatar"]], inputs: { alt: "alt", crossOrigin: "crossOrigin", gap: "gap", icon: "icon", imgDraggable: "imgDraggable", shape: "shape", size: "size", src: "src", srcSet: "srcSet" }, outputs: { xError: "xError" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XAvatar_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XAvatar = __decorate([
+    ProxyCmp({
+        inputs: ['alt', 'crossOrigin', 'gap', 'icon', 'imgDraggable', 'shape', 'size', 'src', 'srcSet']
+    })
+], XAvatar);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XAvatar, [{
+        type: Component,
+        args: [{
+                selector: 'x-avatar',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['alt', 'crossOrigin', 'gap', 'icon', 'imgDraggable', 'shape', 'size', 'src', 'srcSet'],
+                outputs: ['xError'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xError: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XAvatar, { className: "XAvatar", filePath: "lib/proxies.ts", lineNumber: 293 }); })();
+let XBackTop = class XBackTop {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XBackTop_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XBackTop)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XBackTop, selectors: [["x-back-top"]], inputs: { duration: "duration", visibilityHeight: "visibilityHeight" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XBackTop_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XBackTop = __decorate([
+    ProxyCmp({
+        inputs: ['duration', 'visibilityHeight']
+    })
+], XBackTop);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XBackTop, [{
+        type: Component,
+        args: [{
+                selector: 'x-back-top',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['duration', 'visibilityHeight'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XBackTop, { className: "XBackTop", filePath: "lib/proxies.ts", lineNumber: 324 }); })();
+let XBadge = class XBadge {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XBadge_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XBadge)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XBadge, selectors: [["x-badge"]], inputs: { badgeTitle: "badgeTitle", classNames: "classNames", color: "color", count: "count", dot: "dot", offset: "offset", overflowCount: "overflowCount", showZero: "showZero", size: "size", status: "status", styles: "styles", text: "text" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XBadge_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XBadge = __decorate([
+    ProxyCmp({
+        inputs: ['badgeTitle', 'classNames', 'color', 'count', 'dot', 'offset', 'overflowCount', 'showZero', 'size', 'status', 'styles', 'text']
+    })
+], XBadge);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XBadge, [{
+        type: Component,
+        args: [{
+                selector: 'x-badge',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['badgeTitle', 'classNames', 'color', 'count', 'dot', 'offset', 'overflowCount', 'showZero', 'size', 'status', 'styles', 'text'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XBadge, { className: "XBadge", filePath: "lib/proxies.ts", lineNumber: 347 }); })();
+let XBreadcrumb = class XBreadcrumb {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XBreadcrumb_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XBreadcrumb)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XBreadcrumb, selectors: [["x-breadcrumb"]], inputs: { separator: "separator" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XBreadcrumb_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XBreadcrumb = __decorate([
+    ProxyCmp({
+        inputs: ['separator']
+    })
+], XBreadcrumb);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XBreadcrumb, [{
+        type: Component,
+        args: [{
+                selector: 'x-breadcrumb',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['separator'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XBreadcrumb, { className: "XBreadcrumb", filePath: "lib/proxies.ts", lineNumber: 370 }); })();
+let XBreadcrumbItem = class XBreadcrumbItem {
+    z;
+    el;
+    xClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XBreadcrumbItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XBreadcrumbItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XBreadcrumbItem, selectors: [["x-breadcrumb-item"]], inputs: { href: "href", separator: "separator" }, outputs: { xClick: "xClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XBreadcrumbItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XBreadcrumbItem = __decorate([
+    ProxyCmp({
+        inputs: ['href', 'separator']
+    })
+], XBreadcrumbItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XBreadcrumbItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-breadcrumb-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['href', 'separator'],
+                outputs: ['xClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XBreadcrumbItem, { className: "XBreadcrumbItem", filePath: "lib/proxies.ts", lineNumber: 394 }); })();
+let XButton = class XButton {
+    z;
+    el;
+    xClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XButton_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XButton)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XButton, selectors: [["x-button"]], inputs: { block: "block", danger: "danger", disabled: "disabled", ghost: "ghost", href: "href", htmlType: "htmlType", loading: "loading", shape: "shape", size: "size", target: "target", type: "type" }, outputs: { xClick: "xClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XButton_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XButton = __decorate([
+    ProxyCmp({
+        inputs: ['block', 'danger', 'disabled', 'ghost', 'href', 'htmlType', 'loading', 'shape', 'size', 'target', 'type']
+    })
+], XButton);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XButton, [{
+        type: Component,
+        args: [{
+                selector: 'x-button',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['block', 'danger', 'disabled', 'ghost', 'href', 'htmlType', 'loading', 'shape', 'size', 'target', 'type'],
+                outputs: ['xClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XButton, { className: "XButton", filePath: "lib/proxies.ts", lineNumber: 424 }); })();
+let XCaptcha = class XCaptcha {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xValidate = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCaptcha_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCaptcha)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCaptcha, selectors: [["x-captcha"]], inputs: { caseSensitive: "caseSensitive", disabled: "disabled", error: "error", label: "label", length: "length", message: "message", placeholder: "placeholder", required: "required", value: "value" }, outputs: { xChange: "xChange", xValidate: "xValidate" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCaptcha_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCaptcha = __decorate([
+    ProxyCmp({
+        inputs: ['caseSensitive', 'disabled', 'error', 'label', 'length', 'message', 'placeholder', 'required', 'value'],
+        methods: ['validate', 'refresh']
+    })
+], XCaptcha);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCaptcha, [{
+        type: Component,
+        args: [{
+                selector: 'x-captcha',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['caseSensitive', 'disabled', 'error', 'label', 'length', 'message', 'placeholder', 'required', 'value'],
+                outputs: ['xChange', 'xValidate'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xValidate: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCaptcha, { className: "XCaptcha", filePath: "lib/proxies.ts", lineNumber: 455 }); })();
+let XCard = class XCard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCard_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCard)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCard, selectors: [["x-card"]], inputs: { bordered: "bordered", cardTitle: "cardTitle", cover: "cover", extra: "extra", hoverable: "hoverable", loading: "loading", size: "size", type: "type" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCard_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCard = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'cardTitle', 'cover', 'extra', 'hoverable', 'loading', 'size', 'type']
+    })
+], XCard);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCard, [{
+        type: Component,
+        args: [{
+                selector: 'x-card',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bordered', 'cardTitle', 'cover', 'extra', 'hoverable', 'loading', 'size', 'type'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCard, { className: "XCard", filePath: "lib/proxies.ts", lineNumber: 489 }); })();
+let XCarousel = class XCarousel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCarousel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCarousel)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCarousel, selectors: [["x-carousel"]], inputs: { autoplay: "autoplay", dotPosition: "dotPosition", dots: "dots", effect: "effect" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCarousel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCarousel = __decorate([
+    ProxyCmp({
+        inputs: ['autoplay', 'dotPosition', 'dots', 'effect']
+    })
+], XCarousel);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCarousel, [{
+        type: Component,
+        args: [{
+                selector: 'x-carousel',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['autoplay', 'dotPosition', 'dots', 'effect'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCarousel, { className: "XCarousel", filePath: "lib/proxies.ts", lineNumber: 512 }); })();
+let XCascader = class XCascader {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xSearch = new EventEmitter();
+    xDropdownVisibleChange = new EventEmitter();
+    xLoadData = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCascader_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCascader)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCascader, selectors: [["x-cascader"]], inputs: { allowClear: "allowClear", autofocus: "autofocus", changeOnSelect: "changeOnSelect", defaultValue: "defaultValue", disabled: "disabled", displaySeparator: "displaySeparator", expandTrigger: "expandTrigger", fieldNames: "fieldNames", loading: "loading", maxTagCount: "maxTagCount", multiple: "multiple", notFoundContent: "notFoundContent", open: "open", options: "options", placeholder: "placeholder", placement: "placement", showSearch: "showSearch", size: "size", status: "status", value: "value", variant: "variant" }, outputs: { xChange: "xChange", xSearch: "xSearch", xDropdownVisibleChange: "xDropdownVisibleChange", xLoadData: "xLoadData", xFocus: "xFocus", xBlur: "xBlur" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCascader_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCascader = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autofocus', 'changeOnSelect', 'defaultValue', 'disabled', 'displaySeparator', 'expandTrigger', 'fieldNames', 'loading', 'maxTagCount', 'multiple', 'notFoundContent', 'open', 'options', 'placeholder', 'placement', 'showSearch', 'size', 'status', 'value', 'variant'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XCascader);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCascader, [{
+        type: Component,
+        args: [{
+                selector: 'x-cascader',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autofocus', 'changeOnSelect', 'defaultValue', 'disabled', 'displaySeparator', 'expandTrigger', 'fieldNames', 'loading', 'maxTagCount', 'multiple', 'notFoundContent', 'open', 'options', 'placeholder', 'placement', 'showSearch', 'size', 'status', 'value', 'variant'],
+                outputs: ['xChange', 'xSearch', 'xDropdownVisibleChange', 'xLoadData', 'xFocus', 'xBlur'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }], xDropdownVisibleChange: [{
+            type: Output
+        }], xLoadData: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCascader, { className: "XCascader", filePath: "lib/proxies.ts", lineNumber: 537 }); })();
+let XCascaderDropdownContent = class XCascaderDropdownContent {
+    z;
+    el;
+    xItemClick = new EventEmitter();
+    xItemHover = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCascaderDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCascaderDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCascaderDropdownContent, selectors: [["x-cascader-dropdown-content"]], inputs: { activeOptions: "activeOptions", dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", expandTrigger: "expandTrigger", fieldNames: "fieldNames", hoveredPath: "hoveredPath", multiple: "multiple", notFoundContent: "notFoundContent", pageSize: "pageSize", selectedPath: "selectedPath", setDropdownRef: "setDropdownRef" }, outputs: { xItemClick: "xItemClick", xItemHover: "xItemHover" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCascaderDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCascaderDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['activeOptions', 'dropdownClasses', 'dropdownStyle', 'expandTrigger', 'fieldNames', 'hoveredPath', 'multiple', 'notFoundContent', 'pageSize', 'selectedPath', 'setDropdownRef']
+    })
+], XCascaderDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCascaderDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-cascader-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['activeOptions', 'dropdownClasses', 'dropdownStyle', 'expandTrigger', 'fieldNames', 'hoveredPath', 'multiple', 'notFoundContent', 'pageSize', 'selectedPath', 'setDropdownRef'],
+                outputs: ['xItemClick', 'xItemHover'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xItemClick: [{
+            type: Output
+        }], xItemHover: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCascaderDropdownContent, { className: "XCascaderDropdownContent", filePath: "lib/proxies.ts", lineNumber: 597 }); })();
+let XCheckbox = class XCheckbox {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCheckbox_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCheckbox)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCheckbox, selectors: [["x-checkbox"]], inputs: { alignment: "alignment", autoFocus: "autoFocus", checkboxId: "checkboxId", checked: "checked", classNames: "classNames", defaultChecked: "defaultChecked", disabled: "disabled", indeterminate: "indeterminate", name: "name", placement: "placement", styles: "styles", value: "value" }, outputs: { xChange: "xChange", xFocus: "xFocus", xBlur: "xBlur" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCheckbox_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCheckbox = __decorate([
+    ProxyCmp({
+        inputs: ['alignment', 'autoFocus', 'checkboxId', 'checked', 'classNames', 'defaultChecked', 'disabled', 'indeterminate', 'name', 'placement', 'styles', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], XCheckbox);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCheckbox, [{
+        type: Component,
+        args: [{
+                selector: 'x-checkbox',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['alignment', 'autoFocus', 'checkboxId', 'checked', 'classNames', 'defaultChecked', 'disabled', 'indeterminate', 'name', 'placement', 'styles', 'value'],
+                outputs: ['xChange', 'xFocus', 'xBlur'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCheckbox, { className: "XCheckbox", filePath: "lib/proxies.ts", lineNumber: 638 }); })();
+let XCol = class XCol {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCol_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCol)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCol, selectors: [["x-col"]], inputs: { flex: "flex", lg: "lg", md: "md", offset: "offset", order: "order", pull: "pull", push: "push", sm: "sm", span: "span", xl: "xl", xs: "xs", xxl: "xxl" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCol_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCol = __decorate([
+    ProxyCmp({
+        inputs: ['flex', 'lg', 'md', 'offset', 'order', 'pull', 'push', 'sm', 'span', 'xl', 'xs', 'xxl']
+    })
+], XCol);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCol, [{
+        type: Component,
+        args: [{
+                selector: 'x-col',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['flex', 'lg', 'md', 'offset', 'order', 'pull', 'push', 'sm', 'span', 'xl', 'xs', 'xxl'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCol, { className: "XCol", filePath: "lib/proxies.ts", lineNumber: 679 }); })();
+let XCollapse = class XCollapse {
+    z;
+    el;
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCollapse_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCollapse)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCollapse, selectors: [["x-collapse"]], inputs: { accordion: "accordion", activeKey: "activeKey", bordered: "bordered", collapsible: "collapsible", defaultActiveKey: "defaultActiveKey", destroyInactivePanel: "destroyInactivePanel", expandIconPosition: "expandIconPosition", ghost: "ghost", size: "size" }, outputs: { xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCollapse_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCollapse = __decorate([
+    ProxyCmp({
+        inputs: ['accordion', 'activeKey', 'bordered', 'collapsible', 'defaultActiveKey', 'destroyInactivePanel', 'expandIconPosition', 'ghost', 'size']
+    })
+], XCollapse);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCollapse, [{
+        type: Component,
+        args: [{
+                selector: 'x-collapse',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['accordion', 'activeKey', 'bordered', 'collapsible', 'defaultActiveKey', 'destroyInactivePanel', 'expandIconPosition', 'ghost', 'size'],
+                outputs: ['xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCollapse, { className: "XCollapse", filePath: "lib/proxies.ts", lineNumber: 703 }); })();
+let XCollapsePanel = class XCollapsePanel {
+    z;
+    el;
+    xItemClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XCollapsePanel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XCollapsePanel)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XCollapsePanel, selectors: [["x-collapse-panel"]], inputs: { active: "active", collapseSize: "collapseSize", collapsible: "collapsible", destroyInactivePanel: "destroyInactivePanel", expandIconPosition: "expandIconPosition", forceRender: "forceRender", header: "header", panelKey: "panelKey", showArrow: "showArrow" }, outputs: { xItemClick: "xItemClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XCollapsePanel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XCollapsePanel = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'collapseSize', 'collapsible', 'destroyInactivePanel', 'expandIconPosition', 'forceRender', 'header', 'panelKey', 'showArrow']
+    })
+], XCollapsePanel);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XCollapsePanel, [{
+        type: Component,
+        args: [{
+                selector: 'x-collapse-panel',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['active', 'collapseSize', 'collapsible', 'destroyInactivePanel', 'expandIconPosition', 'forceRender', 'header', 'panelKey', 'showArrow'],
+                outputs: ['xItemClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xItemClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XCollapsePanel, { className: "XCollapsePanel", filePath: "lib/proxies.ts", lineNumber: 735 }); })();
+let XColorPicker = class XColorPicker {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xChangeComplete = new EventEmitter();
+    xFormatChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xClear = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XColorPicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XColorPicker)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XColorPicker, selectors: [["x-color-picker"]], inputs: { allowClear: "allowClear", classNames: "classNames", defaultFormat: "defaultFormat", defaultValue: "defaultValue", disabled: "disabled", disabledAlpha: "disabledAlpha", disabledFormat: "disabledFormat", format: "format", open: "open", placement: "placement", presets: "presets", showText: "showText", size: "size", styles: "styles", trigger: "trigger", value: "value" }, outputs: { xChange: "xChange", xChangeComplete: "xChangeComplete", xFormatChange: "xFormatChange", xOpenChange: "xOpenChange", xClear: "xClear" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XColorPicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XColorPicker = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'classNames', 'defaultFormat', 'defaultValue', 'disabled', 'disabledAlpha', 'disabledFormat', 'format', 'open', 'placement', 'presets', 'showText', 'size', 'styles', 'trigger', 'value'],
+        methods: ['getColor']
+    })
+], XColorPicker);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XColorPicker, [{
+        type: Component,
+        args: [{
+                selector: 'x-color-picker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'classNames', 'defaultFormat', 'defaultValue', 'disabled', 'disabledAlpha', 'disabledFormat', 'format', 'open', 'placement', 'presets', 'showText', 'size', 'styles', 'trigger', 'value'],
+                outputs: ['xChange', 'xChangeComplete', 'xFormatChange', 'xOpenChange', 'xClear'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xChangeComplete: [{
+            type: Output
+        }], xFormatChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xClear: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XColorPicker, { className: "XColorPicker", filePath: "lib/proxies.ts", lineNumber: 766 }); })();
+let XComment = class XComment {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XComment_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XComment)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XComment, selectors: [["x-comment"]], inputs: { author: "author", avatar: "avatar", content: "content", datetime: "datetime" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XComment_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XComment = __decorate([
+    ProxyCmp({
+        inputs: ['author', 'avatar', 'content', 'datetime']
+    })
+], XComment);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XComment, [{
+        type: Component,
+        args: [{
+                selector: 'x-comment',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['author', 'avatar', 'content', 'datetime'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XComment, { className: "XComment", filePath: "lib/proxies.ts", lineNumber: 820 }); })();
+let XContent = class XContent {
+    z;
+    el;
+    xScrollStart = new EventEmitter();
+    xScroll = new EventEmitter();
+    xScrollEnd = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XContent, selectors: [["x-content"]], inputs: { scrollEvents: "scrollEvents", scrollX: "scrollX", scrollY: "scrollY" }, outputs: { xScrollStart: "xScrollStart", xScroll: "xScroll", xScrollEnd: "xScrollEnd" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XContent = __decorate([
+    ProxyCmp({
+        inputs: ['scrollEvents', 'scrollX', 'scrollY'],
+        methods: ['getScrollElement', 'scrollToTop', 'scrollToBottom', 'scrollToPoint']
+    })
+], XContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['scrollEvents', 'scrollX', 'scrollY'],
+                outputs: ['xScrollStart', 'xScroll', 'xScrollEnd'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xScrollStart: [{
+            type: Output
+        }], xScroll: [{
+            type: Output
+        }], xScrollEnd: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XContent, { className: "XContent", filePath: "lib/proxies.ts", lineNumber: 845 }); })();
+let XDatePicker = class XDatePicker {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xBlur = new EventEmitter();
+    xFocus = new EventEmitter();
+    xPanelChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDatePicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDatePicker)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDatePicker, selectors: [["x-date-picker"]], inputs: { allowClear: "allowClear", autofocus: "autofocus", bordered: "bordered", defaultPickerValue: "defaultPickerValue", defaultValue: "defaultValue", disabled: "disabled", disabledDate: "disabledDate", format: "format", inputId: "inputId", inputReadOnly: "inputReadOnly", maxDate: "maxDate", minDate: "minDate", name: "name", nextIcon: "nextIcon", open: "open", picker: "picker", placeholder: "placeholder", placement: "placement", prevIcon: "prevIcon", showNow: "showNow", showTime: "showTime", showToday: "showToday", size: "size", status: "status", suffixIcon: "suffixIcon", superNextIcon: "superNextIcon", superPrevIcon: "superPrevIcon", value: "value", weekStartDay: "weekStartDay" }, outputs: { xChange: "xChange", xOpenChange: "xOpenChange", xBlur: "xBlur", xFocus: "xFocus", xPanelChange: "xPanelChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDatePicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDatePicker = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autofocus', 'bordered', 'defaultPickerValue', 'defaultValue', 'disabled', 'disabledDate', 'format', 'inputId', 'inputReadOnly', 'maxDate', 'minDate', 'name', 'nextIcon', 'open', 'picker', 'placeholder', 'placement', 'prevIcon', 'showNow', 'showTime', 'showToday', 'size', 'status', 'suffixIcon', 'superNextIcon', 'superPrevIcon', 'value', 'weekStartDay'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XDatePicker);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDatePicker, [{
+        type: Component,
+        args: [{
+                selector: 'x-date-picker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autofocus', 'bordered', 'defaultPickerValue', 'defaultValue', 'disabled', 'disabledDate', 'format', 'inputId', 'inputReadOnly', 'maxDate', 'minDate', 'name', 'nextIcon', 'open', 'picker', 'placeholder', 'placement', 'prevIcon', 'showNow', 'showTime', 'showToday', 'size', 'status', 'suffixIcon', 'superNextIcon', 'superPrevIcon', 'value', 'weekStartDay'],
+                outputs: ['xChange', 'xOpenChange', 'xBlur', 'xFocus', 'xPanelChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xPanelChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDatePicker, { className: "XDatePicker", filePath: "lib/proxies.ts", lineNumber: 888 }); })();
+let XDatePickerDropdownContent = class XDatePickerDropdownContent {
+    z;
+    el;
+    xDateClick = new EventEmitter();
+    xMonthClick = new EventEmitter();
+    xYearClick = new EventEmitter();
+    xQuarterClick = new EventEmitter();
+    xWeekClick = new EventEmitter();
+    xHeaderAction = new EventEmitter();
+    xTodayClick = new EventEmitter();
+    xNowClick = new EventEmitter();
+    xOkClick = new EventEmitter();
+    xTimeChange = new EventEmitter();
+    xPanelModeChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDatePickerDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDatePickerDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDatePickerDropdownContent, selectors: [["x-date-picker-dropdown-content"]], inputs: { currentViewDate: "currentViewDate", disabledDateFn: "disabledDateFn", dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", hourStep: "hourStep", maxDate: "maxDate", minDate: "minDate", minuteStep: "minuteStep", panelMode: "panelMode", secondStep: "secondStep", selectedDate: "selectedDate", selectedHour: "selectedHour", selectedMinute: "selectedMinute", selectedSecond: "selectedSecond", setDropdownRef: "setDropdownRef", showNow: "showNow", showTime: "showTime", showToday: "showToday", use12Hours: "use12Hours", weekStartDay: "weekStartDay" }, outputs: { xDateClick: "xDateClick", xMonthClick: "xMonthClick", xYearClick: "xYearClick", xQuarterClick: "xQuarterClick", xWeekClick: "xWeekClick", xHeaderAction: "xHeaderAction", xTodayClick: "xTodayClick", xNowClick: "xNowClick", xOkClick: "xOkClick", xTimeChange: "xTimeChange", xPanelModeChange: "xPanelModeChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDatePickerDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDatePickerDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['currentViewDate', 'disabledDateFn', 'dropdownClasses', 'dropdownStyle', 'hourStep', 'maxDate', 'minDate', 'minuteStep', 'panelMode', 'secondStep', 'selectedDate', 'selectedHour', 'selectedMinute', 'selectedSecond', 'setDropdownRef', 'showNow', 'showTime', 'showToday', 'use12Hours', 'weekStartDay']
+    })
+], XDatePickerDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDatePickerDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-date-picker-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['currentViewDate', 'disabledDateFn', 'dropdownClasses', 'dropdownStyle', 'hourStep', 'maxDate', 'minDate', 'minuteStep', 'panelMode', 'secondStep', 'selectedDate', 'selectedHour', 'selectedMinute', 'selectedSecond', 'setDropdownRef', 'showNow', 'showTime', 'showToday', 'use12Hours', 'weekStartDay'],
+                outputs: ['xDateClick', 'xMonthClick', 'xYearClick', 'xQuarterClick', 'xWeekClick', 'xHeaderAction', 'xTodayClick', 'xNowClick', 'xOkClick', 'xTimeChange', 'xPanelModeChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xDateClick: [{
+            type: Output
+        }], xMonthClick: [{
+            type: Output
+        }], xYearClick: [{
+            type: Output
+        }], xQuarterClick: [{
+            type: Output
+        }], xWeekClick: [{
+            type: Output
+        }], xHeaderAction: [{
+            type: Output
+        }], xTodayClick: [{
+            type: Output
+        }], xNowClick: [{
+            type: Output
+        }], xOkClick: [{
+            type: Output
+        }], xTimeChange: [{
+            type: Output
+        }], xPanelModeChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDatePickerDropdownContent, { className: "XDatePickerDropdownContent", filePath: "lib/proxies.ts", lineNumber: 940 }); })();
+let XDescriptions = class XDescriptions {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDescriptions_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDescriptions)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDescriptions, selectors: [["x-descriptions"]], inputs: { bordered: "bordered", colon: "colon", column: "column", contentStyle: "contentStyle", descriptionTitle: "descriptionTitle", items: "items", labelStyle: "labelStyle", layout: "layout", size: "size" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDescriptions_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDescriptions = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'colon', 'column', 'contentStyle', 'descriptionTitle', 'items', 'labelStyle', 'layout', 'size'],
+        methods: ['getColumnCount']
+    })
+], XDescriptions);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDescriptions, [{
+        type: Component,
+        args: [{
+                selector: 'x-descriptions',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bordered', 'colon', 'column', 'contentStyle', 'descriptionTitle', 'items', 'labelStyle', 'layout', 'size'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDescriptions, { className: "XDescriptions", filePath: "lib/proxies.ts", lineNumber: 1028 }); })();
+let XDescriptionsItem = class XDescriptionsItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDescriptionsItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDescriptionsItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDescriptionsItem, selectors: [["x-descriptions-item"]], inputs: { colon: "colon", contentStyle: "contentStyle", label: "label", labelStyle: "labelStyle", span: "span" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDescriptionsItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDescriptionsItem = __decorate([
+    ProxyCmp({
+        inputs: ['colon', 'contentStyle', 'label', 'labelStyle', 'span']
+    })
+], XDescriptionsItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDescriptionsItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-descriptions-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['colon', 'contentStyle', 'label', 'labelStyle', 'span'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDescriptionsItem, { className: "XDescriptionsItem", filePath: "lib/proxies.ts", lineNumber: 1051 }); })();
+let XDivider = class XDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDivider_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDivider)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDivider, selectors: [["x-divider"]], inputs: { dashed: "dashed", orientation: "orientation", orientationMargin: "orientationMargin", plain: "plain", type: "type" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDivider_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDivider = __decorate([
+    ProxyCmp({
+        inputs: ['dashed', 'orientation', 'orientationMargin', 'plain', 'type']
+    })
+], XDivider);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDivider, [{
+        type: Component,
+        args: [{
+                selector: 'x-divider',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['dashed', 'orientation', 'orientationMargin', 'plain', 'type'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDivider, { className: "XDivider", filePath: "lib/proxies.ts", lineNumber: 1074 }); })();
+let XDrawer = class XDrawer {
+    z;
+    el;
+    xClose = new EventEmitter();
+    xAfterOpenChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDrawer_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDrawer)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDrawer, selectors: [["x-drawer"]], inputs: { closable: "closable", destroyOnClose: "destroyOnClose", drawerTitle: "drawerTitle", height: "height", keyboard: "keyboard", mask: "mask", maskClosable: "maskClosable", open: "open", placement: "placement", size: "size", width: "width", zIndex: "zIndex" }, outputs: { xClose: "xClose", xAfterOpenChange: "xAfterOpenChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDrawer_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDrawer = __decorate([
+    ProxyCmp({
+        inputs: ['closable', 'destroyOnClose', 'drawerTitle', 'height', 'keyboard', 'mask', 'maskClosable', 'open', 'placement', 'size', 'width', 'zIndex']
+    })
+], XDrawer);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDrawer, [{
+        type: Component,
+        args: [{
+                selector: 'x-drawer',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['closable', 'destroyOnClose', 'drawerTitle', 'height', 'keyboard', 'mask', 'maskClosable', 'open', 'placement', 'size', 'width', 'zIndex'],
+                outputs: ['xClose', 'xAfterOpenChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }], xAfterOpenChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDrawer, { className: "XDrawer", filePath: "lib/proxies.ts", lineNumber: 1098 }); })();
+let XDrawerContent = class XDrawerContent {
+    z;
+    el;
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDrawerContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDrawerContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDrawerContent, selectors: [["x-drawer-content"]], inputs: { bodyContent: "bodyContent", closable: "closable", drawerTitle: "drawerTitle", extraContent: "extraContent", footerContent: "footerContent", height: "height", keyboard: "keyboard", mask: "mask", maskClosable: "maskClosable", open: "open", placement: "placement", size: "size", titleContent: "titleContent", width: "width", zIndex: "zIndex" }, outputs: { xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDrawerContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDrawerContent = __decorate([
+    ProxyCmp({
+        inputs: ['bodyContent', 'closable', 'drawerTitle', 'extraContent', 'footerContent', 'height', 'keyboard', 'mask', 'maskClosable', 'open', 'placement', 'size', 'titleContent', 'width', 'zIndex']
+    })
+], XDrawerContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDrawerContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-drawer-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bodyContent', 'closable', 'drawerTitle', 'extraContent', 'footerContent', 'height', 'keyboard', 'mask', 'maskClosable', 'open', 'placement', 'size', 'titleContent', 'width', 'zIndex'],
+                outputs: ['xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDrawerContent, { className: "XDrawerContent", filePath: "lib/proxies.ts", lineNumber: 1133 }); })();
+let XDropdown = class XDropdown {
+    z;
+    el;
+    xOpenChange = new EventEmitter();
+    xMenuClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XDropdown_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XDropdown)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XDropdown, selectors: [["x-dropdown"]], inputs: { arrow: "arrow", autoAdjustOverflow: "autoAdjustOverflow", classNames: "classNames", destroyOnHidden: "destroyOnHidden", disabled: "disabled", menu: "menu", open: "open", placement: "placement", styles: "styles", trigger: "trigger" }, outputs: { xOpenChange: "xOpenChange", xMenuClick: "xMenuClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XDropdown_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XDropdown = __decorate([
+    ProxyCmp({
+        inputs: ['arrow', 'autoAdjustOverflow', 'classNames', 'destroyOnHidden', 'disabled', 'menu', 'open', 'placement', 'styles', 'trigger']
+    })
+], XDropdown);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XDropdown, [{
+        type: Component,
+        args: [{
+                selector: 'x-dropdown',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['arrow', 'autoAdjustOverflow', 'classNames', 'destroyOnHidden', 'disabled', 'menu', 'open', 'placement', 'styles', 'trigger'],
+                outputs: ['xOpenChange', 'xMenuClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xOpenChange: [{
+            type: Output
+        }], xMenuClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XDropdown, { className: "XDropdown", filePath: "lib/proxies.ts", lineNumber: 1163 }); })();
+let XEditor = class XEditor {
+    z;
+    el;
+    valueChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XEditor_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XEditor)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XEditor, selectors: [["x-editor"]], inputs: { disabled: "disabled", initialValue: "initialValue", placeholder: "placeholder", showToolbar: "showToolbar", toolbar: "toolbar" }, outputs: { valueChange: "valueChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XEditor_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XEditor = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'initialValue', 'placeholder', 'showToolbar', 'toolbar'],
+        methods: ['getState', 'setState', 'getHTML', 'setHTML', 'focusEditor', 'clear', 'undo', 'redo', 'canUndo', 'canRedo']
+    })
+], XEditor);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XEditor, [{
+        type: Component,
+        args: [{
+                selector: 'x-editor',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabled', 'initialValue', 'placeholder', 'showToolbar', 'toolbar'],
+                outputs: ['valueChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { valueChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XEditor, { className: "XEditor", filePath: "lib/proxies.ts", lineNumber: 1202 }); })();
+let XEmpty = class XEmpty {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XEmpty_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XEmpty)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XEmpty, selectors: [["x-empty"]], inputs: { description: "description", image: "image" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XEmpty_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XEmpty = __decorate([
+    ProxyCmp({
+        inputs: ['description', 'image']
+    })
+], XEmpty);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XEmpty, [{
+        type: Component,
+        args: [{
+                selector: 'x-empty',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['description', 'image'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XEmpty, { className: "XEmpty", filePath: "lib/proxies.ts", lineNumber: 1231 }); })();
+let XFinder = class XFinder {
+    z;
+    el;
+    xSelect = new EventEmitter();
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFinder_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFinder)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFinder, selectors: [["x-finder"]], inputs: { config: "config", displayMode: "displayMode", finderTitle: "finderTitle", visible: "visible" }, outputs: { xSelect: "xSelect", xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFinder_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFinder = __decorate([
+    ProxyCmp({
+        inputs: ['config', 'displayMode', 'finderTitle', 'visible']
+    })
+], XFinder);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFinder, [{
+        type: Component,
+        args: [{
+                selector: 'x-finder',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['config', 'displayMode', 'finderTitle', 'visible'],
+                outputs: ['xSelect', 'xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xSelect: [{
+            type: Output
+        }], xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFinder, { className: "XFinder", filePath: "lib/proxies.ts", lineNumber: 1255 }); })();
+let XFlex = class XFlex {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFlex_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFlex)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFlex, selectors: [["x-flex"]], inputs: { align: "align", component: "component", flex: "flex", gap: "gap", justify: "justify", vertical: "vertical", wrap: "wrap" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFlex_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFlex = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'component', 'flex', 'gap', 'justify', 'vertical', 'wrap']
+    })
+], XFlex);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFlex, [{
+        type: Component,
+        args: [{
+                selector: 'x-flex',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['align', 'component', 'flex', 'gap', 'justify', 'vertical', 'wrap'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFlex, { className: "XFlex", filePath: "lib/proxies.ts", lineNumber: 1291 }); })();
+let XFloatButton = class XFloatButton {
+    z;
+    el;
+    xClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFloatButton_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFloatButton)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFloatButton, selectors: [["x-float-button"]], inputs: { description: "description", href: "href", shape: "shape", target: "target", tooltip: "tooltip", type: "type" }, outputs: { xClick: "xClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFloatButton_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFloatButton = __decorate([
+    ProxyCmp({
+        inputs: ['description', 'href', 'shape', 'target', 'tooltip', 'type']
+    })
+], XFloatButton);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFloatButton, [{
+        type: Component,
+        args: [{
+                selector: 'x-float-button',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['description', 'href', 'shape', 'target', 'tooltip', 'type'],
+                outputs: ['xClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFloatButton, { className: "XFloatButton", filePath: "lib/proxies.ts", lineNumber: 1315 }); })();
+let XFooter = class XFooter {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFooter_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFooter)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFooter, selectors: [["x-footer"]], standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFooter_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFooter = __decorate([
+    ProxyCmp({})
+], XFooter);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFooter, [{
+        type: Component,
+        args: [{
+                selector: 'x-footer',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: [],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFooter, { className: "XFooter", filePath: "lib/proxies.ts", lineNumber: 1343 }); })();
+let XForm = class XForm {
+    z;
+    el;
+    xFinish = new EventEmitter();
+    xFinishFailed = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XForm_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XForm)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XForm, selectors: [["x-form"]], inputs: { colon: "colon", form: "form", hideRequiredMark: "hideRequiredMark", initialValues: "initialValues", layout: "layout", name: "name", size: "size" }, outputs: { xFinish: "xFinish", xFinishFailed: "xFinishFailed" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XForm_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XForm = __decorate([
+    ProxyCmp({
+        inputs: ['colon', 'form', 'hideRequiredMark', 'initialValues', 'layout', 'name', 'size'],
+        methods: ['submit']
+    })
+], XForm);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XForm, [{
+        type: Component,
+        args: [{
+                selector: 'x-form',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['colon', 'form', 'hideRequiredMark', 'initialValues', 'layout', 'name', 'size'],
+                outputs: ['xFinish', 'xFinishFailed'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xFinish: [{
+            type: Output
+        }], xFinishFailed: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XForm, { className: "XForm", filePath: "lib/proxies.ts", lineNumber: 1368 }); })();
+let XFormBuilder = class XFormBuilder {
+    z;
+    el;
+    xChange = new EventEmitter();
+    formSubmit = new EventEmitter();
+    xTableAction = new EventEmitter();
+    formError = new EventEmitter();
+    ready = new EventEmitter();
+    xClick = new EventEmitter();
+    valueChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFormBuilder_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFormBuilder)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFormBuilder, selectors: [["x-form-builder"]], inputs: { context: "context", schema: "schema", value: "value" }, outputs: { xChange: "xChange", formSubmit: "formSubmit", xTableAction: "xTableAction", formError: "formError", ready: "ready", xClick: "xClick", valueChange: "valueChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFormBuilder_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFormBuilder = __decorate([
+    ProxyCmp({
+        inputs: ['context', 'schema', 'value']
+    })
+], XFormBuilder);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFormBuilder, [{
+        type: Component,
+        args: [{
+                selector: 'x-form-builder',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['context', 'schema', 'value'],
+                outputs: ['xChange', 'formSubmit', 'xTableAction', 'formError', 'ready', 'xClick', 'valueChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], formSubmit: [{
+            type: Output
+        }], xTableAction: [{
+            type: Output
+        }], formError: [{
+            type: Output
+        }], ready: [{
+            type: Output
+        }], xClick: [{
+            type: Output
+        }], valueChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFormBuilder, { className: "XFormBuilder", filePath: "lib/proxies.ts", lineNumber: 1403 }); })();
+let XFormItem = class XFormItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XFormItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XFormItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XFormItem, selectors: [["x-form-item"]], inputs: { colon: "colon", extra: "extra", hasFeedback: "hasFeedback", help: "help", label: "label", labelAlign: "labelAlign", labelCol: "labelCol", layout: "layout", name: "name", required: "required", validateStatus: "validateStatus", valuePropName: "valuePropName", wrapperCol: "wrapperCol" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XFormItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XFormItem = __decorate([
+    ProxyCmp({
+        inputs: ['colon', 'extra', 'hasFeedback', 'help', 'label', 'labelAlign', 'labelCol', 'layout', 'name', 'required', 'validateStatus', 'valuePropName', 'wrapperCol']
+    })
+], XFormItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XFormItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-form-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['colon', 'extra', 'hasFeedback', 'help', 'label', 'labelAlign', 'labelCol', 'layout', 'name', 'required', 'validateStatus', 'valuePropName', 'wrapperCol'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XFormItem, { className: "XFormItem", filePath: "lib/proxies.ts", lineNumber: 1456 }); })();
+let XHeader = class XHeader {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XHeader_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XHeader)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XHeader, selectors: [["x-header"]], standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XHeader_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XHeader = __decorate([
+    ProxyCmp({})
+], XHeader);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XHeader, [{
+        type: Component,
+        args: [{
+                selector: 'x-header',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: [],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XHeader, { className: "XHeader", filePath: "lib/proxies.ts", lineNumber: 1478 }); })();
+let XIcon = class XIcon {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XIcon_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XIcon)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XIcon, selectors: [["x-icon"]], inputs: { color: "color", fill: "fill", grade: "grade", name: "name", rotate: "rotate", size: "size", spin: "spin", type: "type", weight: "weight" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XIcon_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XIcon = __decorate([
+    ProxyCmp({
+        inputs: ['color', 'fill', 'grade', 'name', 'rotate', 'size', 'spin', 'type', 'weight']
+    })
+], XIcon);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XIcon, [{
+        type: Component,
+        args: [{
+                selector: 'x-icon',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['color', 'fill', 'grade', 'name', 'rotate', 'size', 'spin', 'type', 'weight'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XIcon, { className: "XIcon", filePath: "lib/proxies.ts", lineNumber: 1501 }); })();
+let XImage = class XImage {
+    z;
+    el;
+    xError = new EventEmitter();
+    xLoad = new EventEmitter();
+    xPreviewVisibleChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XImage_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XImage)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XImage, selectors: [["x-image"]], inputs: { alt: "alt", crossOrigin: "crossOrigin", fallback: "fallback", height: "height", loading: "loading", placeholder: "placeholder", preview: "preview", referrerPolicy: "referrerPolicy", rootClassName: "rootClassName", src: "src", width: "width" }, outputs: { xError: "xError", xLoad: "xLoad", xPreviewVisibleChange: "xPreviewVisibleChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XImage_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XImage = __decorate([
+    ProxyCmp({
+        inputs: ['alt', 'crossOrigin', 'fallback', 'height', 'loading', 'placeholder', 'preview', 'referrerPolicy', 'rootClassName', 'src', 'width']
+    })
+], XImage);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XImage, [{
+        type: Component,
+        args: [{
+                selector: 'x-image',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['alt', 'crossOrigin', 'fallback', 'height', 'loading', 'placeholder', 'preview', 'referrerPolicy', 'rootClassName', 'src', 'width'],
+                outputs: ['xError', 'xLoad', 'xPreviewVisibleChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xError: [{
+            type: Output
+        }], xLoad: [{
+            type: Output
+        }], xPreviewVisibleChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XImage, { className: "XImage", filePath: "lib/proxies.ts", lineNumber: 1525 }); })();
+let XInfiniteScroll = class XInfiniteScroll {
+    z;
+    el;
+    xLoadMore = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XInfiniteScroll_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XInfiniteScroll)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XInfiniteScroll, selectors: [["x-infinite-scroll"]], inputs: { disabled: "disabled", hasMore: "hasMore", loading: "loading", loadingText: "loadingText", noMoreText: "noMoreText", threshold: "threshold" }, outputs: { xLoadMore: "xLoadMore" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XInfiniteScroll_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XInfiniteScroll = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'hasMore', 'loading', 'loadingText', 'noMoreText', 'threshold']
+    })
+], XInfiniteScroll);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XInfiniteScroll, [{
+        type: Component,
+        args: [{
+                selector: 'x-infinite-scroll',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabled', 'hasMore', 'loading', 'loadingText', 'noMoreText', 'threshold'],
+                outputs: ['xLoadMore'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xLoadMore: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XInfiniteScroll, { className: "XInfiniteScroll", filePath: "lib/proxies.ts", lineNumber: 1569 }); })();
+let XInput = class XInput {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xInput = new EventEmitter();
+    xPressEnter = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    xClear = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XInput_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XInput)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XInput, selectors: [["x-input"]], inputs: { addonAfter: "addonAfter", addonBefore: "addonBefore", allowClear: "allowClear", autocomplete: "autocomplete", autofocus: "autofocus", bordered: "bordered", defaultValue: "defaultValue", disabled: "disabled", inputId: "inputId", max: "max", maxLength: "maxLength", min: "min", name: "name", pattern: "pattern", placeholder: "placeholder", prefixIcon: "prefixIcon", readOnly: "readOnly", required: "required", showCount: "showCount", showPasswordToggle: "showPasswordToggle", size: "size", spellcheck: "spellcheck", status: "status", step: "step", suffixIcon: "suffixIcon", type: "type", value: "value", variant: "variant" }, outputs: { xChange: "xChange", xInput: "xInput", xPressEnter: "xPressEnter", xFocus: "xFocus", xBlur: "xBlur", xClear: "xClear" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XInput_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XInput = __decorate([
+    ProxyCmp({
+        inputs: ['addonAfter', 'addonBefore', 'allowClear', 'autocomplete', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'inputId', 'max', 'maxLength', 'min', 'name', 'pattern', 'placeholder', 'prefixIcon', 'readOnly', 'required', 'showCount', 'showPasswordToggle', 'size', 'spellcheck', 'status', 'step', 'suffixIcon', 'type', 'value', 'variant'],
+        methods: ['setFocus', 'setBlur', 'select']
+    })
+], XInput);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XInput, [{
+        type: Component,
+        args: [{
+                selector: 'x-input',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['addonAfter', 'addonBefore', 'allowClear', 'autocomplete', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'inputId', 'max', 'maxLength', 'min', 'name', 'pattern', 'placeholder', 'prefixIcon', 'readOnly', 'required', 'showCount', 'showPasswordToggle', 'size', 'spellcheck', 'status', 'step', 'suffixIcon', 'type', 'value', 'variant'],
+                outputs: ['xChange', 'xInput', 'xPressEnter', 'xFocus', 'xBlur', 'xClear'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xInput: [{
+            type: Output
+        }], xPressEnter: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xClear: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XInput, { className: "XInput", filePath: "lib/proxies.ts", lineNumber: 1600 }); })();
+let XInputNumber = class XInputNumber {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xPressEnter = new EventEmitter();
+    xStep = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XInputNumber_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XInputNumber)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XInputNumber, selectors: [["x-input-number"]], inputs: { addonAfter: "addonAfter", addonBefore: "addonBefore", autoFocus: "autoFocus", changeOnWheel: "changeOnWheel", classNames: "classNames", controls: "controls", decimalSeparator: "decimalSeparator", defaultValue: "defaultValue", disabled: "disabled", formatter: "formatter", keyboard: "keyboard", max: "max", min: "min", parser: "parser", placeholder: "placeholder", precision: "precision", prefixIcon: "prefixIcon", readOnly: "readOnly", size: "size", status: "status", step: "step", stringMode: "stringMode", styles: "styles", suffix: "suffix", value: "value", variant: "variant" }, outputs: { xChange: "xChange", xPressEnter: "xPressEnter", xStep: "xStep", xFocus: "xFocus", xBlur: "xBlur" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XInputNumber_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XInputNumber = __decorate([
+    ProxyCmp({
+        inputs: ['addonAfter', 'addonBefore', 'autoFocus', 'changeOnWheel', 'classNames', 'controls', 'decimalSeparator', 'defaultValue', 'disabled', 'formatter', 'keyboard', 'max', 'min', 'parser', 'placeholder', 'precision', 'prefixIcon', 'readOnly', 'size', 'status', 'step', 'stringMode', 'styles', 'suffix', 'value', 'variant'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XInputNumber);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XInputNumber, [{
+        type: Component,
+        args: [{
+                selector: 'x-input-number',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['addonAfter', 'addonBefore', 'autoFocus', 'changeOnWheel', 'classNames', 'controls', 'decimalSeparator', 'defaultValue', 'disabled', 'formatter', 'keyboard', 'max', 'min', 'parser', 'placeholder', 'precision', 'prefixIcon', 'readOnly', 'size', 'status', 'step', 'stringMode', 'styles', 'suffix', 'value', 'variant'],
+                outputs: ['xChange', 'xPressEnter', 'xStep', 'xFocus', 'xBlur'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xPressEnter: [{
+            type: Output
+        }], xStep: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XInputNumber, { className: "XInputNumber", filePath: "lib/proxies.ts", lineNumber: 1658 }); })();
+let XLayout = class XLayout {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XLayout_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XLayout)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XLayout, selectors: [["x-layout"]], inputs: { fixed: "fixed", hasSiderProp: "hasSiderProp" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XLayout_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XLayout = __decorate([
+    ProxyCmp({
+        inputs: ['fixed', 'hasSiderProp']
+    })
+], XLayout);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XLayout, [{
+        type: Component,
+        args: [{
+                selector: 'x-layout',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['fixed', 'hasSiderProp'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XLayout, { className: "XLayout", filePath: "lib/proxies.ts", lineNumber: 1710 }); })();
+let XList = class XList {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XList_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XList)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XList, selectors: [["x-list"]], inputs: { bordered: "bordered", dataSource: "dataSource", footerText: "footerText", headerText: "headerText", infiniteScroll: "infiniteScroll", loading: "loading", pageSize: "pageSize", renderItem: "renderItem", size: "size", split: "split" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XList_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XList = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'dataSource', 'footerText', 'headerText', 'infiniteScroll', 'loading', 'pageSize', 'renderItem', 'size', 'split']
+    })
+], XList);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XList, [{
+        type: Component,
+        args: [{
+                selector: 'x-list',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bordered', 'dataSource', 'footerText', 'headerText', 'infiniteScroll', 'loading', 'pageSize', 'renderItem', 'size', 'split'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XList, { className: "XList", filePath: "lib/proxies.ts", lineNumber: 1733 }); })();
+let XListItem = class XListItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XListItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XListItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XListItem, selectors: [["x-list-item"]], standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XListItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XListItem = __decorate([
+    ProxyCmp({})
+], XListItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XListItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-list-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: [],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XListItem, { className: "XListItem", filePath: "lib/proxies.ts", lineNumber: 1755 }); })();
+let XMentions = class XMentions {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xSelect = new EventEmitter();
+    xSearch = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMentions_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMentions)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMentions, selectors: [["x-mentions"]], inputs: { disabled: "disabled", loading: "loading", options: "options", placeholder: "placeholder", rows: "rows", triggerPrefix: "triggerPrefix", value: "value" }, outputs: { xChange: "xChange", xSelect: "xSelect", xSearch: "xSearch" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMentions_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMentions = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'loading', 'options', 'placeholder', 'rows', 'triggerPrefix', 'value']
+    })
+], XMentions);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMentions, [{
+        type: Component,
+        args: [{
+                selector: 'x-mentions',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabled', 'loading', 'options', 'placeholder', 'rows', 'triggerPrefix', 'value'],
+                outputs: ['xChange', 'xSelect', 'xSearch'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xSelect: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMentions, { className: "XMentions", filePath: "lib/proxies.ts", lineNumber: 1779 }); })();
+let XMenu = class XMenu {
+    z;
+    el;
+    xSelect = new EventEmitter();
+    xDeselect = new EventEmitter();
+    xClick = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMenu_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMenu)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMenu, selectors: [["x-menu"]], inputs: { defaultOpenKeys: "defaultOpenKeys", defaultSelectedKeys: "defaultSelectedKeys", inlineCollapsed: "inlineCollapsed", inlineIndent: "inlineIndent", mode: "mode", multiple: "multiple", openKeys: "openKeys", selectable: "selectable", selectedKeys: "selectedKeys", subMenuCloseDelay: "subMenuCloseDelay", subMenuOpenDelay: "subMenuOpenDelay", theme: "theme", triggerSubMenuAction: "triggerSubMenuAction" }, outputs: { xSelect: "xSelect", xDeselect: "xDeselect", xClick: "xClick", xOpenChange: "xOpenChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMenu_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMenu = __decorate([
+    ProxyCmp({
+        inputs: ['defaultOpenKeys', 'defaultSelectedKeys', 'inlineCollapsed', 'inlineIndent', 'mode', 'multiple', 'openKeys', 'selectable', 'selectedKeys', 'subMenuCloseDelay', 'subMenuOpenDelay', 'theme', 'triggerSubMenuAction']
+    })
+], XMenu);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMenu, [{
+        type: Component,
+        args: [{
+                selector: 'x-menu',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['defaultOpenKeys', 'defaultSelectedKeys', 'inlineCollapsed', 'inlineIndent', 'mode', 'multiple', 'openKeys', 'selectable', 'selectedKeys', 'subMenuCloseDelay', 'subMenuOpenDelay', 'theme', 'triggerSubMenuAction'],
+                outputs: ['xSelect', 'xDeselect', 'xClick', 'xOpenChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xSelect: [{
+            type: Output
+        }], xDeselect: [{
+            type: Output
+        }], xClick: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMenu, { className: "XMenu", filePath: "lib/proxies.ts", lineNumber: 1821 }); })();
+let XMenuDivider = class XMenuDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMenuDivider_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMenuDivider)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMenuDivider, selectors: [["x-menu-divider"]], inputs: { dashed: "dashed" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMenuDivider_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMenuDivider = __decorate([
+    ProxyCmp({
+        inputs: ['dashed']
+    })
+], XMenuDivider);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMenuDivider, [{
+        type: Component,
+        args: [{
+                selector: 'x-menu-divider',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['dashed'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMenuDivider, { className: "XMenuDivider", filePath: "lib/proxies.ts", lineNumber: 1870 }); })();
+let XMenuItem = class XMenuItem {
+    z;
+    el;
+    xMenuItemClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMenuItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMenuItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMenuItem, selectors: [["x-menu-item"]], inputs: { danger: "danger", disabled: "disabled", itemKey: "itemKey", itemTitle: "itemTitle" }, outputs: { xMenuItemClick: "xMenuItemClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMenuItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMenuItem = __decorate([
+    ProxyCmp({
+        inputs: ['danger', 'disabled', 'itemKey', 'itemTitle']
+    })
+], XMenuItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMenuItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-menu-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['danger', 'disabled', 'itemKey', 'itemTitle'],
+                outputs: ['xMenuItemClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xMenuItemClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMenuItem, { className: "XMenuItem", filePath: "lib/proxies.ts", lineNumber: 1894 }); })();
+let XMenuItemGroup = class XMenuItemGroup {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMenuItemGroup_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMenuItemGroup)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMenuItemGroup, selectors: [["x-menu-item-group"]], inputs: { groupTitle: "groupTitle" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMenuItemGroup_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMenuItemGroup = __decorate([
+    ProxyCmp({
+        inputs: ['groupTitle']
+    })
+], XMenuItemGroup);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMenuItemGroup, [{
+        type: Component,
+        args: [{
+                selector: 'x-menu-item-group',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['groupTitle'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMenuItemGroup, { className: "XMenuItemGroup", filePath: "lib/proxies.ts", lineNumber: 1925 }); })();
+let XMenuSubmenu = class XMenuSubmenu {
+    z;
+    el;
+    xSubmenuToggle = new EventEmitter();
+    xTitleClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMenuSubmenu_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMenuSubmenu)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMenuSubmenu, selectors: [["x-menu-submenu"]], inputs: { disabled: "disabled", itemKey: "itemKey", popupClassName: "popupClassName", popupOffset: "popupOffset" }, outputs: { xSubmenuToggle: "xSubmenuToggle", xTitleClick: "xTitleClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMenuSubmenu_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMenuSubmenu = __decorate([
+    ProxyCmp({
+        inputs: ['disabled', 'itemKey', 'popupClassName', 'popupOffset']
+    })
+], XMenuSubmenu);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMenuSubmenu, [{
+        type: Component,
+        args: [{
+                selector: 'x-menu-submenu',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabled', 'itemKey', 'popupClassName', 'popupOffset'],
+                outputs: ['xSubmenuToggle', 'xTitleClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xSubmenuToggle: [{
+            type: Output
+        }], xTitleClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMenuSubmenu, { className: "XMenuSubmenu", filePath: "lib/proxies.ts", lineNumber: 1949 }); })();
+let XMessage = class XMessage {
+    z;
+    el;
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XMessage_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XMessage)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XMessage, selectors: [["x-message"]], inputs: { content: "content", duration: "duration", icon: "icon", messageKey: "messageKey", type: "type" }, outputs: { xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XMessage_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XMessage = __decorate([
+    ProxyCmp({
+        inputs: ['content', 'duration', 'icon', 'messageKey', 'type'],
+        methods: ['close', 'getClosePromise', 'updateContent', 'updateDuration']
+    })
+], XMessage);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XMessage, [{
+        type: Component,
+        args: [{
+                selector: 'x-message',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['content', 'duration', 'icon', 'messageKey', 'type'],
+                outputs: ['xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XMessage, { className: "XMessage", filePath: "lib/proxies.ts", lineNumber: 1988 }); })();
+let XModal = class XModal {
+    z;
+    el;
+    xOk = new EventEmitter();
+    xCancel = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XModal_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XModal)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XModal, selectors: [["x-modal"]], inputs: { cancelLoading: "cancelLoading", cancelText: "cancelText", centered: "centered", closable: "closable", footer: "footer", mask: "mask", maskClosable: "maskClosable", modalTitle: "modalTitle", okLoading: "okLoading", okText: "okText", okType: "okType", type: "type", visible: "visible", width: "width" }, outputs: { xOk: "xOk", xCancel: "xCancel" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XModal_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XModal = __decorate([
+    ProxyCmp({
+        inputs: ['cancelLoading', 'cancelText', 'centered', 'closable', 'footer', 'mask', 'maskClosable', 'modalTitle', 'okLoading', 'okText', 'okType', 'type', 'visible', 'width']
+    })
+], XModal);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XModal, [{
+        type: Component,
+        args: [{
+                selector: 'x-modal',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['cancelLoading', 'cancelText', 'centered', 'closable', 'footer', 'mask', 'maskClosable', 'modalTitle', 'okLoading', 'okText', 'okType', 'type', 'visible', 'width'],
+                outputs: ['xOk', 'xCancel'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xOk: [{
+            type: Output
+        }], xCancel: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XModal, { className: "XModal", filePath: "lib/proxies.ts", lineNumber: 2018 }); })();
+let XModalContent = class XModalContent {
+    z;
+    el;
+    xOk = new EventEmitter();
+    xCancel = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XModalContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XModalContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XModalContent, selectors: [["x-modal-content"]], inputs: { bodyContent: "bodyContent", bodyStyle: "bodyStyle", cancelLoading: "cancelLoading", cancelText: "cancelText", centered: "centered", closable: "closable", footer: "footer", footerContent: "footerContent", mask: "mask", maskClosable: "maskClosable", maskStyle: "maskStyle", modalTitle: "modalTitle", okDanger: "okDanger", okLoading: "okLoading", okText: "okText", okType: "okType", showHeader: "showHeader", type: "type", width: "width", wrapStyle: "wrapStyle" }, outputs: { xOk: "xOk", xCancel: "xCancel" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XModalContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XModalContent = __decorate([
+    ProxyCmp({
+        inputs: ['bodyContent', 'bodyStyle', 'cancelLoading', 'cancelText', 'centered', 'closable', 'footer', 'footerContent', 'mask', 'maskClosable', 'maskStyle', 'modalTitle', 'okDanger', 'okLoading', 'okText', 'okType', 'showHeader', 'type', 'width', 'wrapStyle']
+    })
+], XModalContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XModalContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-modal-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bodyContent', 'bodyStyle', 'cancelLoading', 'cancelText', 'centered', 'closable', 'footer', 'footerContent', 'mask', 'maskClosable', 'maskStyle', 'modalTitle', 'okDanger', 'okLoading', 'okText', 'okType', 'showHeader', 'type', 'width', 'wrapStyle'],
+                outputs: ['xOk', 'xCancel'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xOk: [{
+            type: Output
+        }], xCancel: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XModalContent, { className: "XModalContent", filePath: "lib/proxies.ts", lineNumber: 2053 }); })();
+let XNotification = class XNotification {
+    z;
+    el;
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XNotification_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XNotification)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XNotification, selectors: [["x-notification"]], inputs: { ariaRole: "ariaRole", btn: "btn", closeIcon: "closeIcon", description: "description", duration: "duration", icon: "icon", message: "message", notificationKey: "notificationKey", pauseOnHover: "pauseOnHover", placement: "placement", showProgress: "showProgress", type: "type" }, outputs: { xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XNotification_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XNotification = __decorate([
+    ProxyCmp({
+        inputs: ['ariaRole', 'btn', 'closeIcon', 'description', 'duration', 'icon', 'message', 'notificationKey', 'pauseOnHover', 'placement', 'showProgress', 'type'],
+        methods: ['close', 'getClosePromise', 'updateMessage', 'updateDescription', 'updateDuration']
+    })
+], XNotification);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XNotification, [{
+        type: Component,
+        args: [{
+                selector: 'x-notification',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['ariaRole', 'btn', 'closeIcon', 'description', 'duration', 'icon', 'message', 'notificationKey', 'pauseOnHover', 'placement', 'showProgress', 'type'],
+                outputs: ['xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XNotification, { className: "XNotification", filePath: "lib/proxies.ts", lineNumber: 2089 }); })();
+let XPageHeader = class XPageHeader {
+    z;
+    el;
+    xBack = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XPageHeader_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XPageHeader)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XPageHeader, selectors: [["x-page-header"]], inputs: { backIcon: "backIcon", headerTitle: "headerTitle", subTitle: "subTitle" }, outputs: { xBack: "xBack" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XPageHeader_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XPageHeader = __decorate([
+    ProxyCmp({
+        inputs: ['backIcon', 'headerTitle', 'subTitle']
+    })
+], XPageHeader);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XPageHeader, [{
+        type: Component,
+        args: [{
+                selector: 'x-page-header',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['backIcon', 'headerTitle', 'subTitle'],
+                outputs: ['xBack'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xBack: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XPageHeader, { className: "XPageHeader", filePath: "lib/proxies.ts", lineNumber: 2119 }); })();
+let XPagination = class XPagination {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xShowSizeChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XPagination_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XPagination)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XPagination, selectors: [["x-pagination"]], inputs: { align: "align", classNames: "classNames", current: "current", defaultCurrent: "defaultCurrent", defaultPageSize: "defaultPageSize", disabled: "disabled", hideOnSinglePage: "hideOnSinglePage", pageSize: "pageSize", pageSizeOptions: "pageSizeOptions", responsive: "responsive", showLessItems: "showLessItems", showQuickJumper: "showQuickJumper", showSizeChanger: "showSizeChanger", showTitle: "showTitle", showTotal: "showTotal", simple: "simple", size: "size", styles: "styles", total: "total", totalBoundaryShowSizeChanger: "totalBoundaryShowSizeChanger" }, outputs: { xChange: "xChange", xShowSizeChange: "xShowSizeChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XPagination_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XPagination = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'classNames', 'current', 'defaultCurrent', 'defaultPageSize', 'disabled', 'hideOnSinglePage', 'pageSize', 'pageSizeOptions', 'responsive', 'showLessItems', 'showQuickJumper', 'showSizeChanger', 'showTitle', 'showTotal', 'simple', 'size', 'styles', 'total', 'totalBoundaryShowSizeChanger']
+    })
+], XPagination);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XPagination, [{
+        type: Component,
+        args: [{
+                selector: 'x-pagination',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['align', 'classNames', 'current', 'defaultCurrent', 'defaultPageSize', 'disabled', 'hideOnSinglePage', 'pageSize', 'pageSizeOptions', 'responsive', 'showLessItems', 'showQuickJumper', 'showSizeChanger', 'showTitle', 'showTotal', 'simple', 'size', 'styles', 'total', 'totalBoundaryShowSizeChanger'],
+                outputs: ['xChange', 'xShowSizeChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xShowSizeChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XPagination, { className: "XPagination", filePath: "lib/proxies.ts", lineNumber: 2149 }); })();
+let XPopconfirm = class XPopconfirm {
+    z;
+    el;
+    xConfirm = new EventEmitter();
+    xCancel = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XPopconfirm_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XPopconfirm)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XPopconfirm, selectors: [["x-popconfirm"]], inputs: { cancelText: "cancelText", confirmTitle: "confirmTitle", disabled: "disabled", okText: "okText", placement: "placement" }, outputs: { xConfirm: "xConfirm", xCancel: "xCancel" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XPopconfirm_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XPopconfirm = __decorate([
+    ProxyCmp({
+        inputs: ['cancelText', 'confirmTitle', 'disabled', 'okText', 'placement']
+    })
+], XPopconfirm);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XPopconfirm, [{
+        type: Component,
+        args: [{
+                selector: 'x-popconfirm',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['cancelText', 'confirmTitle', 'disabled', 'okText', 'placement'],
+                outputs: ['xConfirm', 'xCancel'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xConfirm: [{
+            type: Output
+        }], xCancel: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XPopconfirm, { className: "XPopconfirm", filePath: "lib/proxies.ts", lineNumber: 2188 }); })();
+let XPopover = class XPopover {
+    z;
+    el;
+    xOpenChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XPopover_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XPopover)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XPopover, selectors: [["x-popover"]], inputs: { content: "content", open: "open", placement: "placement", popoverTitle: "popoverTitle", trigger: "trigger" }, outputs: { xOpenChange: "xOpenChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XPopover_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XPopover = __decorate([
+    ProxyCmp({
+        inputs: ['content', 'open', 'placement', 'popoverTitle', 'trigger']
+    })
+], XPopover);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XPopover, [{
+        type: Component,
+        args: [{
+                selector: 'x-popover',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['content', 'open', 'placement', 'popoverTitle', 'trigger'],
+                outputs: ['xOpenChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xOpenChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XPopover, { className: "XPopover", filePath: "lib/proxies.ts", lineNumber: 2223 }); })();
+let XProgress = class XProgress {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XProgress_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XProgress)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XProgress, selectors: [["x-progress"]], inputs: { percent: "percent", showInfo: "showInfo", status: "status", strokeColor: "strokeColor", strokeWidth: "strokeWidth", trailColor: "trailColor", type: "type", width: "width" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XProgress_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XProgress = __decorate([
+    ProxyCmp({
+        inputs: ['percent', 'showInfo', 'status', 'strokeColor', 'strokeWidth', 'trailColor', 'type', 'width']
+    })
+], XProgress);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XProgress, [{
+        type: Component,
+        args: [{
+                selector: 'x-progress',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['percent', 'showInfo', 'status', 'strokeColor', 'strokeWidth', 'trailColor', 'type', 'width'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XProgress, { className: "XProgress", filePath: "lib/proxies.ts", lineNumber: 2252 }); })();
+let XQrCode = class XQrCode {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XQrCode_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XQrCode)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XQrCode, selectors: [["x-qr-code"]], inputs: { bgColor: "bgColor", color: "color", ec: "ec", gradient: "gradient", logo: "logo", size: "size", type: "type", value: "value" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XQrCode_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XQrCode = __decorate([
+    ProxyCmp({
+        inputs: ['bgColor', 'color', 'ec', 'gradient', 'logo', 'size', 'type', 'value']
+    })
+], XQrCode);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XQrCode, [{
+        type: Component,
+        args: [{
+                selector: 'x-qr-code',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bgColor', 'color', 'ec', 'gradient', 'logo', 'size', 'type', 'value'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XQrCode, { className: "XQrCode", filePath: "lib/proxies.ts", lineNumber: 2275 }); })();
+let XRadio = class XRadio {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRadio_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRadio)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRadio, selectors: [["x-radio"]], inputs: { alignment: "alignment", autoFocus: "autoFocus", checked: "checked", classNames: "classNames", defaultChecked: "defaultChecked", disabled: "disabled", name: "name", placement: "placement", radioId: "radioId", styles: "styles", value: "value" }, outputs: { xChange: "xChange", xFocus: "xFocus", xBlur: "xBlur" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRadio_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRadio = __decorate([
+    ProxyCmp({
+        inputs: ['alignment', 'autoFocus', 'checked', 'classNames', 'defaultChecked', 'disabled', 'name', 'placement', 'radioId', 'styles', 'value'],
+        methods: ['setFocus', 'removeFocus']
+    })
+], XRadio);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRadio, [{
+        type: Component,
+        args: [{
+                selector: 'x-radio',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['alignment', 'autoFocus', 'checked', 'classNames', 'defaultChecked', 'disabled', 'name', 'placement', 'radioId', 'styles', 'value'],
+                outputs: ['xChange', 'xFocus', 'xBlur'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRadio, { className: "XRadio", filePath: "lib/proxies.ts", lineNumber: 2300 }); })();
+let XRadioGroup = class XRadioGroup {
+    z;
+    el;
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRadioGroup_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRadioGroup)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRadioGroup, selectors: [["x-radio-group"]], inputs: { alignment: "alignment", buttonStyle: "buttonStyle", classNames: "classNames", defaultValue: "defaultValue", direction: "direction", disabled: "disabled", name: "name", optionType: "optionType", options: "options", placement: "placement", size: "size", styles: "styles", value: "value" }, outputs: { xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRadioGroup_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRadioGroup = __decorate([
+    ProxyCmp({
+        inputs: ['alignment', 'buttonStyle', 'classNames', 'defaultValue', 'direction', 'disabled', 'name', 'optionType', 'options', 'placement', 'size', 'styles', 'value']
+    })
+], XRadioGroup);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRadioGroup, [{
+        type: Component,
+        args: [{
+                selector: 'x-radio-group',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['alignment', 'buttonStyle', 'classNames', 'defaultValue', 'direction', 'disabled', 'name', 'optionType', 'options', 'placement', 'size', 'styles', 'value'],
+                outputs: ['xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRadioGroup, { className: "XRadioGroup", filePath: "lib/proxies.ts", lineNumber: 2342 }); })();
+let XRangePicker = class XRangePicker {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xBlur = new EventEmitter();
+    xFocus = new EventEmitter();
+    xCalendarChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRangePicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRangePicker)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRangePicker, selectors: [["x-range-picker"]], inputs: { allowClear: "allowClear", allowEmpty: "allowEmpty", autofocus: "autofocus", bordered: "bordered", defaultValue: "defaultValue", disabled: "disabled", disabledDate: "disabledDate", format: "format", inputId: "inputId", inputReadOnly: "inputReadOnly", maxDate: "maxDate", minDate: "minDate", name: "name", open: "open", picker: "picker", placeholder: "placeholder", placement: "placement", presets: "presets", separator: "separator", showTime: "showTime", size: "size", status: "status", value: "value", weekStartDay: "weekStartDay" }, outputs: { xChange: "xChange", xOpenChange: "xOpenChange", xBlur: "xBlur", xFocus: "xFocus", xCalendarChange: "xCalendarChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRangePicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRangePicker = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'allowEmpty', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'disabledDate', 'format', 'inputId', 'inputReadOnly', 'maxDate', 'minDate', 'name', 'open', 'picker', 'placeholder', 'placement', 'presets', 'separator', 'showTime', 'size', 'status', 'value', 'weekStartDay'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XRangePicker);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRangePicker, [{
+        type: Component,
+        args: [{
+                selector: 'x-range-picker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'allowEmpty', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'disabledDate', 'format', 'inputId', 'inputReadOnly', 'maxDate', 'minDate', 'name', 'open', 'picker', 'placeholder', 'placement', 'presets', 'separator', 'showTime', 'size', 'status', 'value', 'weekStartDay'],
+                outputs: ['xChange', 'xOpenChange', 'xBlur', 'xFocus', 'xCalendarChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xCalendarChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRangePicker, { className: "XRangePicker", filePath: "lib/proxies.ts", lineNumber: 2375 }); })();
+let XRangePickerDropdownContent = class XRangePickerDropdownContent {
+    z;
+    el;
+    xDateClick = new EventEmitter();
+    xDateHover = new EventEmitter();
+    xHeaderAction = new EventEmitter();
+    xPresetClick = new EventEmitter();
+    xOkClick = new EventEmitter();
+    xMonthClick = new EventEmitter();
+    xYearClick = new EventEmitter();
+    xQuarterClick = new EventEmitter();
+    xPanelModeChange = new EventEmitter();
+    xTimeChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRangePickerDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRangePickerDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRangePickerDropdownContent, selectors: [["x-range-picker-dropdown-content"]], inputs: { activePanel: "activePanel", disabledDateFn: "disabledDateFn", dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", hoveringDate: "hoveringDate", leftPanelMode: "leftPanelMode", leftViewDate: "leftViewDate", maxDate: "maxDate", minDate: "minDate", picker: "picker", presets: "presets", rangeEnd: "rangeEnd", rangeStart: "rangeStart", rightPanelMode: "rightPanelMode", rightViewDate: "rightViewDate", setDropdownRef: "setDropdownRef", showTime: "showTime", weekStartDay: "weekStartDay" }, outputs: { xDateClick: "xDateClick", xDateHover: "xDateHover", xHeaderAction: "xHeaderAction", xPresetClick: "xPresetClick", xOkClick: "xOkClick", xMonthClick: "xMonthClick", xYearClick: "xYearClick", xQuarterClick: "xQuarterClick", xPanelModeChange: "xPanelModeChange", xTimeChange: "xTimeChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRangePickerDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRangePickerDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['activePanel', 'disabledDateFn', 'dropdownClasses', 'dropdownStyle', 'hoveringDate', 'leftPanelMode', 'leftViewDate', 'maxDate', 'minDate', 'picker', 'presets', 'rangeEnd', 'rangeStart', 'rightPanelMode', 'rightViewDate', 'setDropdownRef', 'showTime', 'weekStartDay']
+    })
+], XRangePickerDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRangePickerDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-range-picker-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['activePanel', 'disabledDateFn', 'dropdownClasses', 'dropdownStyle', 'hoveringDate', 'leftPanelMode', 'leftViewDate', 'maxDate', 'minDate', 'picker', 'presets', 'rangeEnd', 'rangeStart', 'rightPanelMode', 'rightViewDate', 'setDropdownRef', 'showTime', 'weekStartDay'],
+                outputs: ['xDateClick', 'xDateHover', 'xHeaderAction', 'xPresetClick', 'xOkClick', 'xMonthClick', 'xYearClick', 'xQuarterClick', 'xPanelModeChange', 'xTimeChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xDateClick: [{
+            type: Output
+        }], xDateHover: [{
+            type: Output
+        }], xHeaderAction: [{
+            type: Output
+        }], xPresetClick: [{
+            type: Output
+        }], xOkClick: [{
+            type: Output
+        }], xMonthClick: [{
+            type: Output
+        }], xYearClick: [{
+            type: Output
+        }], xQuarterClick: [{
+            type: Output
+        }], xPanelModeChange: [{
+            type: Output
+        }], xTimeChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRangePickerDropdownContent, { className: "XRangePickerDropdownContent", filePath: "lib/proxies.ts", lineNumber: 2427 }); })();
+let XRate = class XRate {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xHoverChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRate_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRate)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRate, selectors: [["x-rate"]], inputs: { allowClear: "allowClear", allowHalf: "allowHalf", autoFocus: "autoFocus", character: "character", count: "count", defaultValue: "defaultValue", disabled: "disabled", value: "value" }, outputs: { xChange: "xChange", xHoverChange: "xHoverChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRate_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRate = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'allowHalf', 'autoFocus', 'character', 'count', 'defaultValue', 'disabled', 'value']
+    })
+], XRate);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRate, [{
+        type: Component,
+        args: [{
+                selector: 'x-rate',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'allowHalf', 'autoFocus', 'character', 'count', 'defaultValue', 'disabled', 'value'],
+                outputs: ['xChange', 'xHoverChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xHoverChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRate, { className: "XRate", filePath: "lib/proxies.ts", lineNumber: 2507 }); })();
+let XResult = class XResult {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XResult_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XResult)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XResult, selectors: [["x-result"]], inputs: { classNames: "classNames", iconSize: "iconSize", resultTitle: "resultTitle", status: "status", styles: "styles", subTitle: "subTitle" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XResult_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XResult = __decorate([
+    ProxyCmp({
+        inputs: ['classNames', 'iconSize', 'resultTitle', 'status', 'styles', 'subTitle']
+    })
+], XResult);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XResult, [{
+        type: Component,
+        args: [{
+                selector: 'x-result',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['classNames', 'iconSize', 'resultTitle', 'status', 'styles', 'subTitle'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XResult, { className: "XResult", filePath: "lib/proxies.ts", lineNumber: 2541 }); })();
+let XRow = class XRow {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XRow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRow)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XRow, selectors: [["x-row"]], inputs: { align: "align", gutter: "gutter", justify: "justify", wrap: "wrap" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XRow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XRow = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'gutter', 'justify', 'wrap']
+    })
+], XRow);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRow, [{
+        type: Component,
+        args: [{
+                selector: 'x-row',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['align', 'gutter', 'justify', 'wrap'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XRow, { className: "XRow", filePath: "lib/proxies.ts", lineNumber: 2564 }); })();
+let XSegmented = class XSegmented {
+    z;
+    el;
+    xChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSegmented_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSegmented)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSegmented, selectors: [["x-segmented"]], inputs: { block: "block", defaultValue: "defaultValue", disabled: "disabled", options: "options", size: "size", value: "value" }, outputs: { xChange: "xChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSegmented_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSegmented = __decorate([
+    ProxyCmp({
+        inputs: ['block', 'defaultValue', 'disabled', 'options', 'size', 'value']
+    })
+], XSegmented);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSegmented, [{
+        type: Component,
+        args: [{
+                selector: 'x-segmented',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['block', 'defaultValue', 'disabled', 'options', 'size', 'value'],
+                outputs: ['xChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSegmented, { className: "XSegmented", filePath: "lib/proxies.ts", lineNumber: 2588 }); })();
+let XSelect = class XSelect {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xSearch = new EventEmitter();
+    xDropdownVisibleChange = new EventEmitter();
+    xBlur = new EventEmitter();
+    xFocus = new EventEmitter();
+    xClear = new EventEmitter();
+    xDeselect = new EventEmitter();
+    xSelect = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSelect_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSelect)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSelect, selectors: [["x-select"]], inputs: { allowClear: "allowClear", autofocus: "autofocus", bordered: "bordered", defaultValue: "defaultValue", disabled: "disabled", dropdownClassName: "dropdownClassName", dropdownMatchSelectWidth: "dropdownMatchSelectWidth", dropdownStyle: "dropdownStyle", filterOption: "filterOption", filterSort: "filterSort", inputId: "inputId", labelInValue: "labelInValue", listHeight: "listHeight", loading: "loading", maxTagCount: "maxTagCount", maxTagPlaceholder: "maxTagPlaceholder", maxTagTextLength: "maxTagTextLength", mode: "mode", name: "name", notFoundContent: "notFoundContent", open: "open", options: "options", pageSize: "pageSize", placeholder: "placeholder", placement: "placement", showAction: "showAction", showSearch: "showSearch", size: "size", status: "status", value: "value" }, outputs: { xChange: "xChange", xSearch: "xSearch", xDropdownVisibleChange: "xDropdownVisibleChange", xBlur: "xBlur", xFocus: "xFocus", xClear: "xClear", xDeselect: "xDeselect", xSelect: "xSelect" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSelect_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSelect = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'dropdownClassName', 'dropdownMatchSelectWidth', 'dropdownStyle', 'filterOption', 'filterSort', 'inputId', 'labelInValue', 'listHeight', 'loading', 'maxTagCount', 'maxTagPlaceholder', 'maxTagTextLength', 'mode', 'name', 'notFoundContent', 'open', 'options', 'pageSize', 'placeholder', 'placement', 'showAction', 'showSearch', 'size', 'status', 'value'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XSelect);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSelect, [{
+        type: Component,
+        args: [{
+                selector: 'x-select',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'dropdownClassName', 'dropdownMatchSelectWidth', 'dropdownStyle', 'filterOption', 'filterSort', 'inputId', 'labelInValue', 'listHeight', 'loading', 'maxTagCount', 'maxTagPlaceholder', 'maxTagTextLength', 'mode', 'name', 'notFoundContent', 'open', 'options', 'pageSize', 'placeholder', 'placement', 'showAction', 'showSearch', 'size', 'status', 'value'],
+                outputs: ['xChange', 'xSearch', 'xDropdownVisibleChange', 'xBlur', 'xFocus', 'xClear', 'xDeselect', 'xSelect'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }], xDropdownVisibleChange: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xClear: [{
+            type: Output
+        }], xDeselect: [{
+            type: Output
+        }], xSelect: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSelect, { className: "XSelect", filePath: "lib/proxies.ts", lineNumber: 2621 }); })();
+let XSelectDropdownContent = class XSelectDropdownContent {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSelectDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSelectDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSelectDropdownContent, selectors: [["x-select-dropdown-content"]], inputs: { dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", setDropdownRef: "setDropdownRef" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSelectDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSelectDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['dropdownClasses', 'dropdownStyle', 'setDropdownRef']
+    })
+], XSelectDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSelectDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-select-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['dropdownClasses', 'dropdownStyle', 'setDropdownRef'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSelectDropdownContent, { className: "XSelectDropdownContent", filePath: "lib/proxies.ts", lineNumber: 2688 }); })();
+let XSelectOption = class XSelectOption {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSelectOption_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSelectOption)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSelectOption, selectors: [["x-select-option"]], inputs: { active: "active", disabled: "disabled", label: "label", optionTitle: "optionTitle", selected: "selected", value: "value" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSelectOption_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSelectOption = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'disabled', 'label', 'optionTitle', 'selected', 'value']
+    })
+], XSelectOption);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSelectOption, [{
+        type: Component,
+        args: [{
+                selector: 'x-select-option',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['active', 'disabled', 'label', 'optionTitle', 'selected', 'value'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSelectOption, { className: "XSelectOption", filePath: "lib/proxies.ts", lineNumber: 2711 }); })();
+let XSider = class XSider {
+    z;
+    el;
+    xCollapse = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSider_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSider)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSider, selectors: [["x-sider"]], inputs: { collapsed: "collapsed", collapsedWidth: "collapsedWidth", collapsible: "collapsible", defaultCollapsed: "defaultCollapsed", reverseArrow: "reverseArrow", theme: "theme", trigger: "trigger", width: "width" }, outputs: { xCollapse: "xCollapse" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSider_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSider = __decorate([
+    ProxyCmp({
+        inputs: ['collapsed', 'collapsedWidth', 'collapsible', 'defaultCollapsed', 'reverseArrow', 'theme', 'trigger', 'width']
+    })
+], XSider);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSider, [{
+        type: Component,
+        args: [{
+                selector: 'x-sider',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['collapsed', 'collapsedWidth', 'collapsible', 'defaultCollapsed', 'reverseArrow', 'theme', 'trigger', 'width'],
+                outputs: ['xCollapse'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xCollapse: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSider, { className: "XSider", filePath: "lib/proxies.ts", lineNumber: 2735 }); })();
+let XSkeleton = class XSkeleton {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSkeleton_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSkeleton)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSkeleton, selectors: [["x-skeleton"]], inputs: { active: "active", avatar: "avatar", loading: "loading", paragraph: "paragraph", round: "round", showTitle: "showTitle" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSkeleton_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSkeleton = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'avatar', 'loading', 'paragraph', 'round', 'showTitle']
+    })
+], XSkeleton);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSkeleton, [{
+        type: Component,
+        args: [{
+                selector: 'x-skeleton',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['active', 'avatar', 'loading', 'paragraph', 'round', 'showTitle'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSkeleton, { className: "XSkeleton", filePath: "lib/proxies.ts", lineNumber: 2764 }); })();
+let XSlider = class XSlider {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xAfterChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSlider_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSlider)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSlider, selectors: [["x-slider"]], inputs: { allowCross: "allowCross", defaultValue: "defaultValue", disabled: "disabled", draggableTrack: "draggableTrack", marks: "marks", max: "max", min: "min", pushable: "pushable", range: "range", step: "step", tooltip: "tooltip", value: "value", vertical: "vertical" }, outputs: { xChange: "xChange", xAfterChange: "xAfterChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSlider_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSlider = __decorate([
+    ProxyCmp({
+        inputs: ['allowCross', 'defaultValue', 'disabled', 'draggableTrack', 'marks', 'max', 'min', 'pushable', 'range', 'step', 'tooltip', 'value', 'vertical']
+    })
+], XSlider);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSlider, [{
+        type: Component,
+        args: [{
+                selector: 'x-slider',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowCross', 'defaultValue', 'disabled', 'draggableTrack', 'marks', 'max', 'min', 'pushable', 'range', 'step', 'tooltip', 'value', 'vertical'],
+                outputs: ['xChange', 'xAfterChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xAfterChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSlider, { className: "XSlider", filePath: "lib/proxies.ts", lineNumber: 2788 }); })();
+let XSpace = class XSpace {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSpace_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSpace)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSpace, selectors: [["x-space"]], inputs: { align: "align", block: "block", direction: "direction", size: "size", wrap: "wrap" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSpace_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSpace = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'block', 'direction', 'size', 'wrap']
+    })
+], XSpace);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSpace, [{
+        type: Component,
+        args: [{
+                selector: 'x-space',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['align', 'block', 'direction', 'size', 'wrap'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSpace, { className: "XSpace", filePath: "lib/proxies.ts", lineNumber: 2824 }); })();
+let XSpin = class XSpin {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSpin_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSpin)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSpin, selectors: [["x-spin"]], inputs: { size: "size", spinning: "spinning", tip: "tip" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSpin_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSpin = __decorate([
+    ProxyCmp({
+        inputs: ['size', 'spinning', 'tip']
+    })
+], XSpin);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSpin, [{
+        type: Component,
+        args: [{
+                selector: 'x-spin',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['size', 'spinning', 'tip'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSpin, { className: "XSpin", filePath: "lib/proxies.ts", lineNumber: 2847 }); })();
+let XSplitter = class XSplitter {
+    z;
+    el;
+    xResize = new EventEmitter();
+    xResizeStart = new EventEmitter();
+    xResizeEnd = new EventEmitter();
+    xCollapse = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSplitter_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSplitter)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSplitter, selectors: [["x-splitter"]], inputs: { classNames: "classNames", collapsibleIcon: "collapsibleIcon", draggerIcon: "draggerIcon", layout: "layout", lazy: "lazy", orientation: "orientation", styles: "styles", vertical: "vertical" }, outputs: { xResize: "xResize", xResizeStart: "xResizeStart", xResizeEnd: "xResizeEnd", xCollapse: "xCollapse" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSplitter_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSplitter = __decorate([
+    ProxyCmp({
+        inputs: ['classNames', 'collapsibleIcon', 'draggerIcon', 'layout', 'lazy', 'orientation', 'styles', 'vertical']
+    })
+], XSplitter);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSplitter, [{
+        type: Component,
+        args: [{
+                selector: 'x-splitter',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['classNames', 'collapsibleIcon', 'draggerIcon', 'layout', 'lazy', 'orientation', 'styles', 'vertical'],
+                outputs: ['xResize', 'xResizeStart', 'xResizeEnd', 'xCollapse'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xResize: [{
+            type: Output
+        }], xResizeStart: [{
+            type: Output
+        }], xResizeEnd: [{
+            type: Output
+        }], xCollapse: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSplitter, { className: "XSplitter", filePath: "lib/proxies.ts", lineNumber: 2871 }); })();
+let XSplitterPanel = class XSplitterPanel {
+    z;
+    el;
+    xPanelResizeStart = new EventEmitter();
+    xPanelCollapse = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSplitterPanel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSplitterPanel)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSplitterPanel, selectors: [["x-splitter-panel"]], inputs: { collapsible: "collapsible", defaultSize: "defaultSize", max: "max", min: "min", resizable: "resizable", size: "size" }, outputs: { xPanelResizeStart: "xPanelResizeStart", xPanelCollapse: "xPanelCollapse" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSplitterPanel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSplitterPanel = __decorate([
+    ProxyCmp({
+        inputs: ['collapsible', 'defaultSize', 'max', 'min', 'resizable', 'size']
+    })
+], XSplitterPanel);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSplitterPanel, [{
+        type: Component,
+        args: [{
+                selector: 'x-splitter-panel',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['collapsible', 'defaultSize', 'max', 'min', 'resizable', 'size'],
+                outputs: ['xPanelResizeStart', 'xPanelCollapse'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xPanelResizeStart: [{
+            type: Output
+        }], xPanelCollapse: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSplitterPanel, { className: "XSplitterPanel", filePath: "lib/proxies.ts", lineNumber: 2918 }); })();
+let XStatistic = class XStatistic {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XStatistic_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XStatistic)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XStatistic, selectors: [["x-statistic"]], inputs: { decimalSeparator: "decimalSeparator", groupSeparator: "groupSeparator", loading: "loading", precision: "precision", statisticTitle: "statisticTitle", suffix: "suffix", value: "value", valuePrefix: "valuePrefix" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XStatistic_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XStatistic = __decorate([
+    ProxyCmp({
+        inputs: ['decimalSeparator', 'groupSeparator', 'loading', 'precision', 'statisticTitle', 'suffix', 'value', 'valuePrefix']
+    })
+], XStatistic);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XStatistic, [{
+        type: Component,
+        args: [{
+                selector: 'x-statistic',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['decimalSeparator', 'groupSeparator', 'loading', 'precision', 'statisticTitle', 'suffix', 'value', 'valuePrefix'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XStatistic, { className: "XStatistic", filePath: "lib/proxies.ts", lineNumber: 2955 }); })();
+let XStep = class XStep {
+    z;
+    el;
+    xStepClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XStep_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XStep)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XStep, selectors: [["x-step"]], inputs: { description: "description", disabled: "disabled", icon: "icon", percent: "percent", status: "status", stepTitle: "stepTitle", subTitle: "subTitle" }, outputs: { xStepClick: "xStepClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XStep_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XStep = __decorate([
+    ProxyCmp({
+        inputs: ['description', 'disabled', 'icon', 'percent', 'status', 'stepTitle', 'subTitle']
+    })
+], XStep);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XStep, [{
+        type: Component,
+        args: [{
+                selector: 'x-step',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['description', 'disabled', 'icon', 'percent', 'status', 'stepTitle', 'subTitle'],
+                outputs: ['xStepClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xStepClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XStep, { className: "XStep", filePath: "lib/proxies.ts", lineNumber: 2979 }); })();
+let XSteps = class XSteps {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xStepClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSteps_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSteps)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSteps, selectors: [["x-steps"]], inputs: { classNames: "classNames", current: "current", direction: "direction", initial: "initial", items: "items", labelPlacement: "labelPlacement", percent: "percent", progressDot: "progressDot", responsive: "responsive", size: "size", status: "status", styles: "styles", titlePlacement: "titlePlacement", type: "type", variant: "variant" }, outputs: { xChange: "xChange", xStepClick: "xStepClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSteps_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSteps = __decorate([
+    ProxyCmp({
+        inputs: ['classNames', 'current', 'direction', 'initial', 'items', 'labelPlacement', 'percent', 'progressDot', 'responsive', 'size', 'status', 'styles', 'titlePlacement', 'type', 'variant'],
+        methods: ['next', 'prev', 'goTo']
+    })
+], XSteps);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSteps, [{
+        type: Component,
+        args: [{
+                selector: 'x-steps',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['classNames', 'current', 'direction', 'initial', 'items', 'labelPlacement', 'percent', 'progressDot', 'responsive', 'size', 'status', 'styles', 'titlePlacement', 'type', 'variant'],
+                outputs: ['xChange', 'xStepClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xStepClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSteps, { className: "XSteps", filePath: "lib/proxies.ts", lineNumber: 3012 }); })();
+let XSwitch = class XSwitch {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XSwitch_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XSwitch)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XSwitch, selectors: [["x-switch"]], inputs: { autoFocus: "autoFocus", checked: "checked", checkedChildren: "checkedChildren", defaultChecked: "defaultChecked", disabled: "disabled", loading: "loading", size: "size", unCheckedChildren: "unCheckedChildren" }, outputs: { xChange: "xChange", xClick: "xClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XSwitch_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XSwitch = __decorate([
+    ProxyCmp({
+        inputs: ['autoFocus', 'checked', 'checkedChildren', 'defaultChecked', 'disabled', 'loading', 'size', 'unCheckedChildren']
+    })
+], XSwitch);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XSwitch, [{
+        type: Component,
+        args: [{
+                selector: 'x-switch',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['autoFocus', 'checked', 'checkedChildren', 'defaultChecked', 'disabled', 'loading', 'size', 'unCheckedChildren'],
+                outputs: ['xChange', 'xClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XSwitch, { className: "XSwitch", filePath: "lib/proxies.ts", lineNumber: 3049 }); })();
+let XTabPane = class XTabPane {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTabPane_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTabPane)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTabPane, selectors: [["x-tab-pane"]], inputs: { active: "active", closable: "closable", destroyInactiveTabPane: "destroyInactiveTabPane", forceRender: "forceRender", icon: "icon", tab: "tab", tabKey: "tabKey" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTabPane_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTabPane = __decorate([
+    ProxyCmp({
+        inputs: ['active', 'closable', 'destroyInactiveTabPane', 'forceRender', 'icon', 'tab', 'tabKey']
+    })
+], XTabPane);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTabPane, [{
+        type: Component,
+        args: [{
+                selector: 'x-tab-pane',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['active', 'closable', 'destroyInactiveTabPane', 'forceRender', 'icon', 'tab', 'tabKey'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTabPane, { className: "XTabPane", filePath: "lib/proxies.ts", lineNumber: 3085 }); })();
+let XTable = class XTable {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xRowClick = new EventEmitter();
+    xRowDoubleClick = new EventEmitter();
+    xSelectionChange = new EventEmitter();
+    xExpand = new EventEmitter();
+    xExpandedRowsChange = new EventEmitter();
+    xColumnSort = new EventEmitter();
+    xDragSort = new EventEmitter();
+    xDataDisplayChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTable_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTable)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTable, selectors: [["x-table"]], inputs: { bordered: "bordered", classNames: "classNames", columns: "columns", dataSource: "dataSource", draggableColumns: "draggableColumns", draggableRows: "draggableRows", emptyText: "emptyText", expandable: "expandable", headerRowEvents: "headerRowEvents", loading: "loading", pagination: "pagination", resizableColumns: "resizableColumns", rowClassName: "rowClassName", rowEvents: "rowEvents", rowKey: "rowKey", rowSelection: "rowSelection", showHeader: "showHeader", showSorterTooltip: "showSorterTooltip", size: "size", sortDirections: "sortDirections", sticky: "sticky", styles: "styles", tableFooter: "tableFooter", tableLayout: "tableLayout", tableScroll: "tableScroll", tableTitle: "tableTitle", virtual: "virtual" }, outputs: { xChange: "xChange", xRowClick: "xRowClick", xRowDoubleClick: "xRowDoubleClick", xSelectionChange: "xSelectionChange", xExpand: "xExpand", xExpandedRowsChange: "xExpandedRowsChange", xColumnSort: "xColumnSort", xDragSort: "xDragSort", xDataDisplayChange: "xDataDisplayChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTable_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTable = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'classNames', 'columns', 'dataSource', 'draggableColumns', 'draggableRows', 'emptyText', 'expandable', 'headerRowEvents', 'loading', 'pagination', 'resizableColumns', 'rowClassName', 'rowEvents', 'rowKey', 'rowSelection', 'showHeader', 'showSorterTooltip', 'size', 'sortDirections', 'sticky', 'styles', 'tableFooter', 'tableLayout', 'tableScroll', 'tableTitle', 'virtual'],
+        methods: ['getSelectedRowKeys', 'setSelectedRowKeys', 'clearSelection', 'getExpandedRowKeys', 'scrollToRow']
+    })
+], XTable);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTable, [{
+        type: Component,
+        args: [{
+                selector: 'x-table',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bordered', 'classNames', 'columns', 'dataSource', 'draggableColumns', 'draggableRows', 'emptyText', 'expandable', 'headerRowEvents', 'loading', 'pagination', 'resizableColumns', 'rowClassName', 'rowEvents', 'rowKey', 'rowSelection', 'showHeader', 'showSorterTooltip', 'size', 'sortDirections', 'sticky', 'styles', 'tableFooter', 'tableLayout', 'tableScroll', 'tableTitle', 'virtual'],
+                outputs: ['xChange', 'xRowClick', 'xRowDoubleClick', 'xSelectionChange', 'xExpand', 'xExpandedRowsChange', 'xColumnSort', 'xDragSort', 'xDataDisplayChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xRowClick: [{
+            type: Output
+        }], xRowDoubleClick: [{
+            type: Output
+        }], xSelectionChange: [{
+            type: Output
+        }], xExpand: [{
+            type: Output
+        }], xExpandedRowsChange: [{
+            type: Output
+        }], xColumnSort: [{
+            type: Output
+        }], xDragSort: [{
+            type: Output
+        }], xDataDisplayChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTable, { className: "XTable", filePath: "lib/proxies.ts", lineNumber: 3110 }); })();
+let XTableCell = class XTableCell {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTableCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTableCell)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTableCell, selectors: [["x-table-cell"]], inputs: { align: "align", cellClass: "cellClass", colSpan: "colSpan", customStyle: "customStyle", dataIndex: "dataIndex", rowSpan: "rowSpan" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTableCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTableCell = __decorate([
+    ProxyCmp({
+        inputs: ['align', 'cellClass', 'colSpan', 'customStyle', 'dataIndex', 'rowSpan']
+    })
+], XTableCell);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTableCell, [{
+        type: Component,
+        args: [{
+                selector: 'x-table-cell',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['align', 'cellClass', 'colSpan', 'customStyle', 'dataIndex', 'rowSpan'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTableCell, { className: "XTableCell", filePath: "lib/proxies.ts", lineNumber: 3186 }); })();
+let XTableRow = class XTableRow {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTableRow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTableRow)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTableRow, selectors: [["x-table-row"]], inputs: { columns: "columns", index: "index", record: "record" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTableRow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTableRow = __decorate([
+    ProxyCmp({
+        inputs: ['columns', 'index', 'record']
+    })
+], XTableRow);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTableRow, [{
+        type: Component,
+        args: [{
+                selector: 'x-table-row',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['columns', 'index', 'record'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTableRow, { className: "XTableRow", filePath: "lib/proxies.ts", lineNumber: 3209 }); })();
+let XTabs = class XTabs {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xTabClick = new EventEmitter();
+    xEdit = new EventEmitter();
+    xTabScroll = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTabs_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTabs)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTabs, selectors: [["x-tabs"]], inputs: { activeKey: "activeKey", addIcon: "addIcon", animated: "animated", centered: "centered", classNames: "classNames", defaultActiveKey: "defaultActiveKey", destroyInactiveTabPane: "destroyInactiveTabPane", hideAdd: "hideAdd", indicator: "indicator", items: "items", removeIcon: "removeIcon", size: "size", styles: "styles", tabBarExtraContent: "tabBarExtraContent", tabBarGutter: "tabBarGutter", tabBarStyle: "tabBarStyle", tabPlacement: "tabPlacement", type: "type" }, outputs: { xChange: "xChange", xTabClick: "xTabClick", xEdit: "xEdit", xTabScroll: "xTabScroll" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTabs_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTabs = __decorate([
+    ProxyCmp({
+        inputs: ['activeKey', 'addIcon', 'animated', 'centered', 'classNames', 'defaultActiveKey', 'destroyInactiveTabPane', 'hideAdd', 'indicator', 'items', 'removeIcon', 'size', 'styles', 'tabBarExtraContent', 'tabBarGutter', 'tabBarStyle', 'tabPlacement', 'type'],
+        methods: ['getActiveKey', 'setActiveKey']
+    })
+], XTabs);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTabs, [{
+        type: Component,
+        args: [{
+                selector: 'x-tabs',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['activeKey', 'addIcon', 'animated', 'centered', 'classNames', 'defaultActiveKey', 'destroyInactiveTabPane', 'hideAdd', 'indicator', 'items', 'removeIcon', 'size', 'styles', 'tabBarExtraContent', 'tabBarGutter', 'tabBarStyle', 'tabPlacement', 'type'],
+                outputs: ['xChange', 'xTabClick', 'xEdit', 'xTabScroll'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xTabClick: [{
+            type: Output
+        }], xEdit: [{
+            type: Output
+        }], xTabScroll: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTabs, { className: "XTabs", filePath: "lib/proxies.ts", lineNumber: 3234 }); })();
+let XTag = class XTag {
+    z;
+    el;
+    xClose = new EventEmitter();
+    xClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTag_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTag)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTag, selectors: [["x-tag"]], inputs: { bordered: "bordered", closable: "closable", closeIcon: "closeIcon", color: "color", disabled: "disabled", href: "href", target: "target", variant: "variant", visible: "visible" }, outputs: { xClose: "xClose", xClick: "xClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTag_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTag = __decorate([
+    ProxyCmp({
+        inputs: ['bordered', 'closable', 'closeIcon', 'color', 'disabled', 'href', 'target', 'variant', 'visible']
+    })
+], XTag);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTag, [{
+        type: Component,
+        args: [{
+                selector: 'x-tag',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['bordered', 'closable', 'closeIcon', 'color', 'disabled', 'href', 'target', 'variant', 'visible'],
+                outputs: ['xClose', 'xClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xClose: [{
+            type: Output
+        }], xClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTag, { className: "XTag", filePath: "lib/proxies.ts", lineNumber: 3284 }); })();
+let XTextarea = class XTextarea {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xInput = new EventEmitter();
+    xPressEnter = new EventEmitter();
+    xResize = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTextarea_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTextarea)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTextarea, selectors: [["x-textarea"]], inputs: { allowClear: "allowClear", autoSize: "autoSize", bordered: "bordered", defaultValue: "defaultValue", disabled: "disabled", maxLength: "maxLength", placeholder: "placeholder", rows: "rows", showCount: "showCount", status: "status", value: "value" }, outputs: { xChange: "xChange", xInput: "xInput", xPressEnter: "xPressEnter", xResize: "xResize" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTextarea_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTextarea = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autoSize', 'bordered', 'defaultValue', 'disabled', 'maxLength', 'placeholder', 'rows', 'showCount', 'status', 'value']
+    })
+], XTextarea);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTextarea, [{
+        type: Component,
+        args: [{
+                selector: 'x-textarea',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autoSize', 'bordered', 'defaultValue', 'disabled', 'maxLength', 'placeholder', 'rows', 'showCount', 'status', 'value'],
+                outputs: ['xChange', 'xInput', 'xPressEnter', 'xResize'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xInput: [{
+            type: Output
+        }], xPressEnter: [{
+            type: Output
+        }], xResize: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTextarea, { className: "XTextarea", filePath: "lib/proxies.ts", lineNumber: 3319 }); })();
+let XTimePicker = class XTimePicker {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xBlur = new EventEmitter();
+    xFocus = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTimePicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTimePicker)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTimePicker, selectors: [["x-time-picker"]], inputs: { allowClear: "allowClear", autofocus: "autofocus", bordered: "bordered", defaultValue: "defaultValue", disabled: "disabled", disabledTime: "disabledTime", format: "format", hourStep: "hourStep", inputId: "inputId", inputReadOnly: "inputReadOnly", minuteStep: "minuteStep", name: "name", open: "open", placeholder: "placeholder", placement: "placement", secondStep: "secondStep", showNow: "showNow", showSecond: "showSecond", size: "size", status: "status", use12Hours: "use12Hours", value: "value" }, outputs: { xChange: "xChange", xOpenChange: "xOpenChange", xBlur: "xBlur", xFocus: "xFocus" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTimePicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTimePicker = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'disabledTime', 'format', 'hourStep', 'inputId', 'inputReadOnly', 'minuteStep', 'name', 'open', 'placeholder', 'placement', 'secondStep', 'showNow', 'showSecond', 'size', 'status', 'use12Hours', 'value'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XTimePicker);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTimePicker, [{
+        type: Component,
+        args: [{
+                selector: 'x-time-picker',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autofocus', 'bordered', 'defaultValue', 'disabled', 'disabledTime', 'format', 'hourStep', 'inputId', 'inputReadOnly', 'minuteStep', 'name', 'open', 'placeholder', 'placement', 'secondStep', 'showNow', 'showSecond', 'size', 'status', 'use12Hours', 'value'],
+                outputs: ['xChange', 'xOpenChange', 'xBlur', 'xFocus'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTimePicker, { className: "XTimePicker", filePath: "lib/proxies.ts", lineNumber: 3365 }); })();
+let XTimePickerDropdownContent = class XTimePickerDropdownContent {
+    z;
+    el;
+    xTimeChange = new EventEmitter();
+    xNowClick = new EventEmitter();
+    xOkClick = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTimePickerDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTimePickerDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTimePickerDropdownContent, selectors: [["x-time-picker-dropdown-content"]], inputs: { disabledHours: "disabledHours", disabledMinutes: "disabledMinutes", disabledSeconds: "disabledSeconds", dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", hourStep: "hourStep", minuteStep: "minuteStep", secondStep: "secondStep", selectedHour: "selectedHour", selectedMinute: "selectedMinute", selectedPeriod: "selectedPeriod", selectedSecond: "selectedSecond", setDropdownRef: "setDropdownRef", showNow: "showNow", showSecond: "showSecond", use12Hours: "use12Hours" }, outputs: { xTimeChange: "xTimeChange", xNowClick: "xNowClick", xOkClick: "xOkClick" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTimePickerDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTimePickerDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['disabledHours', 'disabledMinutes', 'disabledSeconds', 'dropdownClasses', 'dropdownStyle', 'hourStep', 'minuteStep', 'secondStep', 'selectedHour', 'selectedMinute', 'selectedPeriod', 'selectedSecond', 'setDropdownRef', 'showNow', 'showSecond', 'use12Hours']
+    })
+], XTimePickerDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTimePickerDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-time-picker-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['disabledHours', 'disabledMinutes', 'disabledSeconds', 'dropdownClasses', 'dropdownStyle', 'hourStep', 'minuteStep', 'secondStep', 'selectedHour', 'selectedMinute', 'selectedPeriod', 'selectedSecond', 'setDropdownRef', 'showNow', 'showSecond', 'use12Hours'],
+                outputs: ['xTimeChange', 'xNowClick', 'xOkClick'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xTimeChange: [{
+            type: Output
+        }], xNowClick: [{
+            type: Output
+        }], xOkClick: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTimePickerDropdownContent, { className: "XTimePickerDropdownContent", filePath: "lib/proxies.ts", lineNumber: 3412 }); })();
+let XTimeline = class XTimeline {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTimeline_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTimeline)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTimeline, selectors: [["x-timeline"]], inputs: { mode: "mode", pending: "pending", reverse: "reverse" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTimeline_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTimeline = __decorate([
+    ProxyCmp({
+        inputs: ['mode', 'pending', 'reverse']
+    })
+], XTimeline);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTimeline, [{
+        type: Component,
+        args: [{
+                selector: 'x-timeline',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['mode', 'pending', 'reverse'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTimeline, { className: "XTimeline", filePath: "lib/proxies.ts", lineNumber: 3453 }); })();
+let XTimelineItem = class XTimelineItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTimelineItem_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTimelineItem)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTimelineItem, selectors: [["x-timeline-item"]], inputs: { color: "color", label: "label", position: "position" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTimelineItem_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTimelineItem = __decorate([
+    ProxyCmp({
+        inputs: ['color', 'label', 'position']
+    })
+], XTimelineItem);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTimelineItem, [{
+        type: Component,
+        args: [{
+                selector: 'x-timeline-item',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['color', 'label', 'position'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTimelineItem, { className: "XTimelineItem", filePath: "lib/proxies.ts", lineNumber: 3476 }); })();
+let XTooltip = class XTooltip {
+    z;
+    el;
+    openChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTooltip_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTooltip)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTooltip, selectors: [["x-tooltip"]], inputs: { arrow: "arrow", autoAdjustOverflow: "autoAdjustOverflow", classNames: "classNames", color: "color", defaultOpen: "defaultOpen", destroyTooltipOnHide: "destroyTooltipOnHide", mouseEnterDelay: "mouseEnterDelay", mouseLeaveDelay: "mouseLeaveDelay", open: "open", placement: "placement", styles: "styles", tooltipTitle: "tooltipTitle", trigger: "trigger", zIndex: "zIndex" }, outputs: { openChange: "openChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTooltip_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTooltip = __decorate([
+    ProxyCmp({
+        inputs: ['arrow', 'autoAdjustOverflow', 'classNames', 'color', 'defaultOpen', 'destroyTooltipOnHide', 'mouseEnterDelay', 'mouseLeaveDelay', 'open', 'placement', 'styles', 'tooltipTitle', 'trigger', 'zIndex'],
+        methods: ['show', 'hide']
+    })
+], XTooltip);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTooltip, [{
+        type: Component,
+        args: [{
+                selector: 'x-tooltip',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['arrow', 'autoAdjustOverflow', 'classNames', 'color', 'defaultOpen', 'destroyTooltipOnHide', 'mouseEnterDelay', 'mouseLeaveDelay', 'open', 'placement', 'styles', 'tooltipTitle', 'trigger', 'zIndex'],
+                outputs: ['openChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { openChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTooltip, { className: "XTooltip", filePath: "lib/proxies.ts", lineNumber: 3501 }); })();
+let XTour = class XTour {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xClose = new EventEmitter();
+    xFinish = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTour_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTour)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTour, selectors: [["x-tour"]], inputs: { arrow: "arrow", current: "current", mask: "mask", open: "open", steps: "steps", zIndex: "zIndex" }, outputs: { xChange: "xChange", xClose: "xClose", xFinish: "xFinish" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTour_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTour = __decorate([
+    ProxyCmp({
+        inputs: ['arrow', 'current', 'mask', 'open', 'steps', 'zIndex']
+    })
+], XTour);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTour, [{
+        type: Component,
+        args: [{
+                selector: 'x-tour',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['arrow', 'current', 'mask', 'open', 'steps', 'zIndex'],
+                outputs: ['xChange', 'xClose', 'xFinish'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xClose: [{
+            type: Output
+        }], xFinish: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTour, { className: "XTour", filePath: "lib/proxies.ts", lineNumber: 3533 }); })();
+let XTourPanel = class XTourPanel {
+    z;
+    el;
+    xNext = new EventEmitter();
+    xPrev = new EventEmitter();
+    xClose = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTourPanel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTourPanel)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTourPanel, selectors: [["x-tour-panel"]], inputs: { arrow: "arrow", current: "current", placement: "placement", step: "step", total: "total" }, outputs: { xNext: "xNext", xPrev: "xPrev", xClose: "xClose" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTourPanel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTourPanel = __decorate([
+    ProxyCmp({
+        inputs: ['arrow', 'current', 'placement', 'step', 'total']
+    })
+], XTourPanel);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTourPanel, [{
+        type: Component,
+        args: [{
+                selector: 'x-tour-panel',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['arrow', 'current', 'placement', 'step', 'total'],
+                outputs: ['xNext', 'xPrev', 'xClose'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xNext: [{
+            type: Output
+        }], xPrev: [{
+            type: Output
+        }], xClose: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTourPanel, { className: "XTourPanel", filePath: "lib/proxies.ts", lineNumber: 3573 }); })();
+let XTransfer = class XTransfer {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xSelectChange = new EventEmitter();
+    xSearch = new EventEmitter();
+    xScroll = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTransfer_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTransfer)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTransfer, selectors: [["x-transfer"]], inputs: { dataSource: "dataSource", disabled: "disabled", listHeight: "listHeight", listWidth: "listWidth", notFoundContent: "notFoundContent", oneWay: "oneWay", operations: "operations", pageSize: "pageSize", pagination: "pagination", searchPlaceholder: "searchPlaceholder", selectedKeys: "selectedKeys", showSearch: "showSearch", showSelectAll: "showSelectAll", targetKeys: "targetKeys", titles: "titles" }, outputs: { xChange: "xChange", xSelectChange: "xSelectChange", xSearch: "xSearch", xScroll: "xScroll" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTransfer_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTransfer = __decorate([
+    ProxyCmp({
+        inputs: ['dataSource', 'disabled', 'listHeight', 'listWidth', 'notFoundContent', 'oneWay', 'operations', 'pageSize', 'pagination', 'searchPlaceholder', 'selectedKeys', 'showSearch', 'showSelectAll', 'targetKeys', 'titles']
+    })
+], XTransfer);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTransfer, [{
+        type: Component,
+        args: [{
+                selector: 'x-transfer',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['dataSource', 'disabled', 'listHeight', 'listWidth', 'notFoundContent', 'oneWay', 'operations', 'pageSize', 'pagination', 'searchPlaceholder', 'selectedKeys', 'showSearch', 'showSelectAll', 'targetKeys', 'titles'],
+                outputs: ['xChange', 'xSelectChange', 'xSearch', 'xScroll'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xSelectChange: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }], xScroll: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTransfer, { className: "XTransfer", filePath: "lib/proxies.ts", lineNumber: 3613 }); })();
+let XTree = class XTree {
+    z;
+    el;
+    xExpand = new EventEmitter();
+    xSelect = new EventEmitter();
+    xCheck = new EventEmitter();
+    xDragStart = new EventEmitter();
+    xDragEnter = new EventEmitter();
+    xDragOver = new EventEmitter();
+    xDragLeave = new EventEmitter();
+    xDragEnd = new EventEmitter();
+    xDrop = new EventEmitter();
+    xLoadData = new EventEmitter();
+    xAction = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTree_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTree)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTree, selectors: [["x-tree"]], inputs: { actions: "actions", allowDrag: "allowDrag", autoExpandParent: "autoExpandParent", blockNode: "blockNode", checkStrictly: "checkStrictly", checkable: "checkable", checkedKeys: "checkedKeys", defaultCheckedKeys: "defaultCheckedKeys", defaultExpandAll: "defaultExpandAll", defaultExpandedKeys: "defaultExpandedKeys", defaultSelectedKeys: "defaultSelectedKeys", disabled: "disabled", expandedKeys: "expandedKeys", filterTreeNode: "filterTreeNode", filterValue: "filterValue", height: "height", itemHeight: "itemHeight", multiple: "multiple", selectable: "selectable", selectedKeys: "selectedKeys", showActions: "showActions", showIcon: "showIcon", showLine: "showLine", treeData: "treeData", virtual: "virtual" }, outputs: { xExpand: "xExpand", xSelect: "xSelect", xCheck: "xCheck", xDragStart: "xDragStart", xDragEnter: "xDragEnter", xDragOver: "xDragOver", xDragLeave: "xDragLeave", xDragEnd: "xDragEnd", xDrop: "xDrop", xLoadData: "xLoadData", xAction: "xAction" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTree_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTree = __decorate([
+    ProxyCmp({
+        inputs: ['actions', 'allowDrag', 'autoExpandParent', 'blockNode', 'checkStrictly', 'checkable', 'checkedKeys', 'defaultCheckedKeys', 'defaultExpandAll', 'defaultExpandedKeys', 'defaultSelectedKeys', 'disabled', 'expandedKeys', 'filterTreeNode', 'filterValue', 'height', 'itemHeight', 'multiple', 'selectable', 'selectedKeys', 'showActions', 'showIcon', 'showLine', 'treeData', 'virtual']
+    })
+], XTree);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTree, [{
+        type: Component,
+        args: [{
+                selector: 'x-tree',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['actions', 'allowDrag', 'autoExpandParent', 'blockNode', 'checkStrictly', 'checkable', 'checkedKeys', 'defaultCheckedKeys', 'defaultExpandAll', 'defaultExpandedKeys', 'defaultSelectedKeys', 'disabled', 'expandedKeys', 'filterTreeNode', 'filterValue', 'height', 'itemHeight', 'multiple', 'selectable', 'selectedKeys', 'showActions', 'showIcon', 'showLine', 'treeData', 'virtual'],
+                outputs: ['xExpand', 'xSelect', 'xCheck', 'xDragStart', 'xDragEnter', 'xDragOver', 'xDragLeave', 'xDragEnd', 'xDrop', 'xLoadData', 'xAction'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xExpand: [{
+            type: Output
+        }], xSelect: [{
+            type: Output
+        }], xCheck: [{
+            type: Output
+        }], xDragStart: [{
+            type: Output
+        }], xDragEnter: [{
+            type: Output
+        }], xDragOver: [{
+            type: Output
+        }], xDragLeave: [{
+            type: Output
+        }], xDragEnd: [{
+            type: Output
+        }], xDrop: [{
+            type: Output
+        }], xLoadData: [{
+            type: Output
+        }], xAction: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTree, { className: "XTree", filePath: "lib/proxies.ts", lineNumber: 3663 }); })();
+let XTreeSelect = class XTreeSelect {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xOpenChange = new EventEmitter();
+    xTreeExpand = new EventEmitter();
+    xSearch = new EventEmitter();
+    xFocus = new EventEmitter();
+    xBlur = new EventEmitter();
+    xDropdownVisibleChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTreeSelect_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTreeSelect)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTreeSelect, selectors: [["x-tree-select"]], inputs: { allowClear: "allowClear", autofocus: "autofocus", defaultExpandAll: "defaultExpandAll", defaultExpandedKeys: "defaultExpandedKeys", defaultValue: "defaultValue", disabled: "disabled", fieldNames: "fieldNames", filterTreeNode: "filterTreeNode", inputId: "inputId", labelInValue: "labelInValue", listHeight: "listHeight", loading: "loading", maxTagCount: "maxTagCount", maxTagPlaceholder: "maxTagPlaceholder", multiple: "multiple", name: "name", notFoundContent: "notFoundContent", open: "open", placeholder: "placeholder", placement: "placement", popupMatchSelectWidth: "popupMatchSelectWidth", showArrow: "showArrow", showCheckedStrategy: "showCheckedStrategy", showSearch: "showSearch", size: "size", status: "status", treeCheckStrictly: "treeCheckStrictly", treeCheckable: "treeCheckable", treeData: "treeData", treeDefaultExpandParent: "treeDefaultExpandParent", treeExpandedKeys: "treeExpandedKeys", treeIcon: "treeIcon", treeLine: "treeLine", treeNodeFilterProp: "treeNodeFilterProp", value: "value", variant: "variant", virtual: "virtual" }, outputs: { xChange: "xChange", xOpenChange: "xOpenChange", xTreeExpand: "xTreeExpand", xSearch: "xSearch", xFocus: "xFocus", xBlur: "xBlur", xDropdownVisibleChange: "xDropdownVisibleChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTreeSelect_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTreeSelect = __decorate([
+    ProxyCmp({
+        inputs: ['allowClear', 'autofocus', 'defaultExpandAll', 'defaultExpandedKeys', 'defaultValue', 'disabled', 'fieldNames', 'filterTreeNode', 'inputId', 'labelInValue', 'listHeight', 'loading', 'maxTagCount', 'maxTagPlaceholder', 'multiple', 'name', 'notFoundContent', 'open', 'placeholder', 'placement', 'popupMatchSelectWidth', 'showArrow', 'showCheckedStrategy', 'showSearch', 'size', 'status', 'treeCheckStrictly', 'treeCheckable', 'treeData', 'treeDefaultExpandParent', 'treeExpandedKeys', 'treeIcon', 'treeLine', 'treeNodeFilterProp', 'value', 'variant', 'virtual'],
+        methods: ['setFocus', 'setBlur']
+    })
+], XTreeSelect);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTreeSelect, [{
+        type: Component,
+        args: [{
+                selector: 'x-tree-select',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['allowClear', 'autofocus', 'defaultExpandAll', 'defaultExpandedKeys', 'defaultValue', 'disabled', 'fieldNames', 'filterTreeNode', 'inputId', 'labelInValue', 'listHeight', 'loading', 'maxTagCount', 'maxTagPlaceholder', 'multiple', 'name', 'notFoundContent', 'open', 'placeholder', 'placement', 'popupMatchSelectWidth', 'showArrow', 'showCheckedStrategy', 'showSearch', 'size', 'status', 'treeCheckStrictly', 'treeCheckable', 'treeData', 'treeDefaultExpandParent', 'treeExpandedKeys', 'treeIcon', 'treeLine', 'treeNodeFilterProp', 'value', 'variant', 'virtual'],
+                outputs: ['xChange', 'xOpenChange', 'xTreeExpand', 'xSearch', 'xFocus', 'xBlur', 'xDropdownVisibleChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xOpenChange: [{
+            type: Output
+        }], xTreeExpand: [{
+            type: Output
+        }], xSearch: [{
+            type: Output
+        }], xFocus: [{
+            type: Output
+        }], xBlur: [{
+            type: Output
+        }], xDropdownVisibleChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTreeSelect, { className: "XTreeSelect", filePath: "lib/proxies.ts", lineNumber: 3750 }); })();
+let XTreeSelectDropdownContent = class XTreeSelectDropdownContent {
+    z;
+    el;
+    xNodeClick = new EventEmitter();
+    xNodeExpand = new EventEmitter();
+    xNodeCheck = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTreeSelectDropdownContent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTreeSelectDropdownContent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTreeSelectDropdownContent, selectors: [["x-tree-select-dropdown-content"]], inputs: { checkedKeys: "checkedKeys", dropdownClasses: "dropdownClasses", dropdownStyle: "dropdownStyle", expandedKeys: "expandedKeys", fieldNames: "fieldNames", filterTreeNode: "filterTreeNode", halfCheckedKeys: "halfCheckedKeys", multiple: "multiple", notFoundContent: "notFoundContent", searchValue: "searchValue", selectedValues: "selectedValues", setDropdownRef: "setDropdownRef", treeCheckable: "treeCheckable", treeData: "treeData", treeLine: "treeLine" }, outputs: { xNodeClick: "xNodeClick", xNodeExpand: "xNodeExpand", xNodeCheck: "xNodeCheck" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTreeSelectDropdownContent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTreeSelectDropdownContent = __decorate([
+    ProxyCmp({
+        inputs: ['checkedKeys', 'dropdownClasses', 'dropdownStyle', 'expandedKeys', 'fieldNames', 'filterTreeNode', 'halfCheckedKeys', 'multiple', 'notFoundContent', 'searchValue', 'selectedValues', 'setDropdownRef', 'treeCheckable', 'treeData', 'treeLine']
+    })
+], XTreeSelectDropdownContent);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTreeSelectDropdownContent, [{
+        type: Component,
+        args: [{
+                selector: 'x-tree-select-dropdown-content',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['checkedKeys', 'dropdownClasses', 'dropdownStyle', 'expandedKeys', 'fieldNames', 'filterTreeNode', 'halfCheckedKeys', 'multiple', 'notFoundContent', 'searchValue', 'selectedValues', 'setDropdownRef', 'treeCheckable', 'treeData', 'treeLine'],
+                outputs: ['xNodeClick', 'xNodeExpand', 'xNodeCheck'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xNodeClick: [{
+            type: Output
+        }], xNodeExpand: [{
+            type: Output
+        }], xNodeCheck: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTreeSelectDropdownContent, { className: "XTreeSelectDropdownContent", filePath: "lib/proxies.ts", lineNumber: 3814 }); })();
+let XTypography = class XTypography {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XTypography_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTypography)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XTypography, selectors: [["x-typography"]], inputs: { code: "code", delete: "delete", disabled: "disabled", href: "href", italic: "italic", keyboard: "keyboard", level: "level", mark: "mark", strong: "strong", target: "target", type: "type", underline: "underline" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XTypography_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XTypography = __decorate([
+    ProxyCmp({
+        inputs: ['code', 'delete', 'disabled', 'href', 'italic', 'keyboard', 'level', 'mark', 'strong', 'target', 'type', 'underline']
+    })
+], XTypography);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTypography, [{
+        type: Component,
+        args: [{
+                selector: 'x-typography',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['code', 'delete', 'disabled', 'href', 'italic', 'keyboard', 'level', 'mark', 'strong', 'target', 'type', 'underline'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XTypography, { className: "XTypography", filePath: "lib/proxies.ts", lineNumber: 3857 }); })();
+let XUpload = class XUpload {
+    z;
+    el;
+    xChange = new EventEmitter();
+    xRemove = new EventEmitter();
+    xPreview = new EventEmitter();
+    xDownload = new EventEmitter();
+    xDrop = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XUpload_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XUpload)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XUpload, selectors: [["x-upload"]], inputs: { accept: "accept", action: "action", classNames: "classNames", data: "data", defaultFileList: "defaultFileList", directory: "directory", disabled: "disabled", drag: "drag", fileList: "fileList", headers: "headers", listType: "listType", maxCount: "maxCount", method: "method", multiple: "multiple", name: "name", openFileDialogOnClick: "openFileDialogOnClick", progress: "progress", showUploadList: "showUploadList", styles: "styles", withCredentials: "withCredentials" }, outputs: { xChange: "xChange", xRemove: "xRemove", xPreview: "xPreview", xDownload: "xDownload", xDrop: "xDrop" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XUpload_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XUpload = __decorate([
+    ProxyCmp({
+        inputs: ['accept', 'action', 'classNames', 'data', 'defaultFileList', 'directory', 'disabled', 'drag', 'fileList', 'headers', 'listType', 'maxCount', 'method', 'multiple', 'name', 'openFileDialogOnClick', 'progress', 'showUploadList', 'styles', 'withCredentials'],
+        methods: ['upload', 'abort']
+    })
+], XUpload);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XUpload, [{
+        type: Component,
+        args: [{
+                selector: 'x-upload',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['accept', 'action', 'classNames', 'data', 'defaultFileList', 'directory', 'disabled', 'drag', 'fileList', 'headers', 'listType', 'maxCount', 'method', 'multiple', 'name', 'openFileDialogOnClick', 'progress', 'showUploadList', 'styles', 'withCredentials'],
+                outputs: ['xChange', 'xRemove', 'xPreview', 'xDownload', 'xDrop'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xChange: [{
+            type: Output
+        }], xRemove: [{
+            type: Output
+        }], xPreview: [{
+            type: Output
+        }], xDownload: [{
+            type: Output
+        }], xDrop: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XUpload, { className: "XUpload", filePath: "lib/proxies.ts", lineNumber: 3882 }); })();
+let XVirtualScroll = class XVirtualScroll {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XVirtualScroll_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XVirtualScroll)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XVirtualScroll, selectors: [["x-virtual-scroll"]], inputs: { height: "height", hoverable: "hoverable", itemClass: "itemClass", itemHeight: "itemHeight", items: "items", overscan: "overscan", width: "width" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XVirtualScroll_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XVirtualScroll = __decorate([
+    ProxyCmp({
+        inputs: ['height', 'hoverable', 'itemClass', 'itemHeight', 'items', 'overscan', 'width'],
+        methods: ['scrollToIndex', 'getScrollTop', 'getVisibleRange']
+    })
+], XVirtualScroll);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XVirtualScroll, [{
+        type: Component,
+        args: [{
+                selector: 'x-virtual-scroll',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['height', 'hoverable', 'itemClass', 'itemHeight', 'items', 'overscan', 'width'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XVirtualScroll, { className: "XVirtualScroll", filePath: "lib/proxies.ts", lineNumber: 3938 }); })();
+let XWorkflow = class XWorkflow {
+    z;
+    el;
+    xNodesChange = new EventEmitter();
+    xEdgesChange = new EventEmitter();
+    xViewportChange = new EventEmitter();
+    xNodeClick = new EventEmitter();
+    xEdgeClick = new EventEmitter();
+    xConnect = new EventEmitter();
+    xWorkflowChange = new EventEmitter();
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XWorkflow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XWorkflow)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XWorkflow, selectors: [["x-workflow"]], inputs: { background: "background", displayMode: "displayMode", edgeRoutingMode: "edgeRoutingMode", edges: "edges", fitView: "fitView", interactive: "interactive", nodeToolbarMode: "nodeToolbarMode", nodeToolbarVisible: "nodeToolbarVisible", nodes: "nodes", snapToGridValue: "snapToGridValue", theme: "theme", tool: "tool", turboMode: "turboMode", users: "users", viewportValue: "viewportValue" }, outputs: { xNodesChange: "xNodesChange", xEdgesChange: "xEdgesChange", xViewportChange: "xViewportChange", xNodeClick: "xNodeClick", xEdgeClick: "xEdgeClick", xConnect: "xConnect", xWorkflowChange: "xWorkflowChange" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XWorkflow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XWorkflow = __decorate([
+    ProxyCmp({
+        inputs: ['background', 'displayMode', 'edgeRoutingMode', 'edges', 'fitView', 'interactive', 'nodeToolbarMode', 'nodeToolbarVisible', 'nodes', 'snapToGridValue', 'theme', 'tool', 'turboMode', 'users', 'viewportValue'],
+        methods: ['forceLayout']
+    })
+], XWorkflow);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XWorkflow, [{
+        type: Component,
+        args: [{
+                selector: 'x-workflow',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['background', 'displayMode', 'edgeRoutingMode', 'edges', 'fitView', 'interactive', 'nodeToolbarMode', 'nodeToolbarVisible', 'nodes', 'snapToGridValue', 'theme', 'tool', 'turboMode', 'users', 'viewportValue'],
+                outputs: ['xNodesChange', 'xEdgesChange', 'xViewportChange', 'xNodeClick', 'xEdgeClick', 'xConnect', 'xWorkflowChange'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], { xNodesChange: [{
+            type: Output
+        }], xEdgesChange: [{
+            type: Output
+        }], xViewportChange: [{
+            type: Output
+        }], xNodeClick: [{
+            type: Output
+        }], xEdgeClick: [{
+            type: Output
+        }], xConnect: [{
+            type: Output
+        }], xWorkflowChange: [{
+            type: Output
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XWorkflow, { className: "XWorkflow", filePath: "lib/proxies.ts", lineNumber: 3963 }); })();
+let XWorkflowBuilder = class XWorkflowBuilder {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    static ɵfac = function XWorkflowBuilder_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XWorkflowBuilder)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: XWorkflowBuilder, selectors: [["x-workflow-builder"]], inputs: { builderTitle: "builderTitle", initialEdges: "initialEdges", initialNodes: "initialNodes" }, standalone: false, ngContentSelectors: _c0, decls: 1, vars: 0, template: function XWorkflowBuilder_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+};
+XWorkflowBuilder = __decorate([
+    ProxyCmp({
+        inputs: ['builderTitle', 'initialEdges', 'initialNodes']
+    })
+], XWorkflowBuilder);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XWorkflowBuilder, [{
+        type: Component,
+        args: [{
+                selector: 'x-workflow-builder',
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content></ng-content>',
+                // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                inputs: ['builderTitle', 'initialEdges', 'initialNodes'],
+                standalone: false
+            }]
+    }], () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(XWorkflowBuilder, { className: "XWorkflowBuilder", filePath: "lib/proxies.ts", lineNumber: 4013 }); })();
+
+const DIRECTIVES = [
+    XAddress,
+    XAffix,
+    XAlert,
+    XAnchor,
+    XAnchorLink,
+    XApp,
+    XAutoComplete,
+    XAutoCompleteDropdownContent,
+    XAvatar,
+    XBackTop,
+    XBadge,
+    XBreadcrumb,
+    XBreadcrumbItem,
+    XButton,
+    XCaptcha,
+    XCard,
+    XCarousel,
+    XCascader,
+    XCascaderDropdownContent,
+    XCheckbox,
+    XCol,
+    XCollapse,
+    XCollapsePanel,
+    XColorPicker,
+    XComment,
+    XContent,
+    XDatePicker,
+    XDatePickerDropdownContent,
+    XDescriptions,
+    XDescriptionsItem,
+    XDivider,
+    XDrawer,
+    XDrawerContent,
+    XDropdown,
+    XEditor,
+    XEmpty,
+    XFinder,
+    XFlex,
+    XFloatButton,
+    XFooter,
+    XForm,
+    XFormBuilder,
+    XFormItem,
+    XHeader,
+    XIcon,
+    XImage,
+    XInfiniteScroll,
+    XInput,
+    XInputNumber,
+    XLayout,
+    XList,
+    XListItem,
+    XMentions,
+    XMenu,
+    XMenuDivider,
+    XMenuItem,
+    XMenuItemGroup,
+    XMenuSubmenu,
+    XMessage,
+    XModal,
+    XModalContent,
+    XNotification,
+    XPageHeader,
+    XPagination,
+    XPopconfirm,
+    XPopover,
+    XProgress,
+    XQrCode,
+    XRadio,
+    XRadioGroup,
+    XRangePicker,
+    XRangePickerDropdownContent,
+    XRate,
+    XResult,
+    XRow,
+    XSegmented,
+    XSelect,
+    XSelectDropdownContent,
+    XSelectOption,
+    XSider,
+    XSkeleton,
+    XSlider,
+    XSpace,
+    XSpin,
+    XSplitter,
+    XSplitterPanel,
+    XStatistic,
+    XStep,
+    XSteps,
+    XSwitch,
+    XTabPane,
+    XTable,
+    XTableCell,
+    XTableRow,
+    XTabs,
+    XTag,
+    XTextarea,
+    XTimePicker,
+    XTimePickerDropdownContent,
+    XTimeline,
+    XTimelineItem,
+    XTooltip,
+    XTour,
+    XTourPanel,
+    XTransfer,
+    XTree,
+    XTreeSelect,
+    XTreeSelectDropdownContent,
+    XTypography,
+    XUpload,
+    XVirtualScroll,
+    XWorkflow,
+    XWorkflowBuilder
+];
+
+const providexlabs = () => provideAppInitializer(() => {
+    defineCustomElements();
+});
+
+class XRowCell {
+    xRowCell = '';
+    template = inject((TemplateRef));
+    static ɵfac = function XRowCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XRowCell)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: XRowCell, selectors: [["", "xRowCell", ""]], inputs: { xRowCell: "xRowCell" }, standalone: false });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XRowCell, [{
+        type: Directive,
+        args: [{
+                selector: '[xRowCell]',
+                standalone: false
+            }]
+    }], null, { xRowCell: [{
+            type: Input
+        }] }); })();
+
+class XTableDirective {
+    host = inject(XTable);
+    _cdr = inject(ChangeDetectorRef);
+    rowCells;
+    _originalColumns = [];
+    _isUpdating = false;
+    set columns(v) {
+        if (this._isUpdating)
+            return;
+        this._originalColumns = v || [];
+        this.reapplyColumns();
+    }
+    ngAfterContentInit() {
+        this.rowCells.changes.subscribe(() => {
+            this.reapplyColumns();
+            this._cdr.markForCheck();
+        });
+        // Initial apply
+        this.reapplyColumns();
+    }
+    ngOnDestroy() { }
+    reapplyColumns() {
+        if (this._isUpdating || !this.rowCells)
+            return;
+        this._isUpdating = true;
+        const availableCells = this.rowCells.toArray();
+        const newColumns = (this._originalColumns || []).map(col => {
+            const colId = (Array.isArray(col.dataIndex) ? col.dataIndex.join('.') : col.dataIndex) || col.key;
+            const rowCell = availableCells.find(c => c.xRowCell === colId);
+            if (rowCell) {
+                return {
+                    ...col,
+                    render: (value, record, index) => {
+                        const viewRef = rowCell.template.createEmbeddedView({
+                            value,
+                            record,
+                            index
+                        });
+                        viewRef.detectChanges();
+                        if (viewRef.rootNodes.length === 1 && viewRef.rootNodes[0] instanceof HTMLElement) {
+                            return viewRef.rootNodes[0];
+                        }
+                        const container = document.createElement('div');
+                        container.className = 'x-table-cell-custom-wrapper';
+                        viewRef.rootNodes.forEach(node => container.appendChild(node));
+                        return container;
+                    }
+                };
+            }
+            return col;
+        });
+        // Update host columns directly without breaking proxy logic
+        this.host.columns = newColumns;
+        this._isUpdating = false;
+    }
+    static ɵfac = function XTableDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XTableDirective)(); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: XTableDirective, selectors: [["x-table", "xTable", ""]], contentQueries: function XTableDirective_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, XRowCell, 5, XRowCell);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.rowCells = _t);
+        } }, inputs: { columns: "columns" }, standalone: false });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XTableDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'x-table[xTable]',
+                standalone: false
+            }]
+    }], null, { rowCells: [{
+            type: ContentChildren,
+            args: [XRowCell, { descendants: true, read: XRowCell }]
+        }], columns: [{
+            type: Input,
+            args: ['columns']
+        }] }); })();
+
+class XlabsModule {
+    constructor() {
+        defineCustomElements();
+    }
+    static forRoot(config = {}) {
+        console.log(config);
+        return {
+            ngModule: XlabsModule,
+            providers: [
+                providexlabs()
+            ],
+        };
+    }
+    static ɵfac = function XlabsModule_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || XlabsModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: XlabsModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(XlabsModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [...DIRECTIVES, XTableDirective, XRowCell],
+                exports: [...DIRECTIVES, XTableDirective, XRowCell],
+                imports: [CommonModule],
+            }]
+    }], () => [], null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(XlabsModule, { declarations: [XAddress, XAffix, XAlert, XAnchor, XAnchorLink, XApp, XAutoComplete, XAutoCompleteDropdownContent, XAvatar, XBackTop, XBadge, XBreadcrumb, XBreadcrumbItem, XButton, XCaptcha, XCard, XCarousel, XCascader, XCascaderDropdownContent, XCheckbox, XCol, XCollapse, XCollapsePanel, XColorPicker, XComment, XContent, XDatePicker, XDatePickerDropdownContent, XDescriptions, XDescriptionsItem, XDivider, XDrawer, XDrawerContent, XDropdown, XEditor, XEmpty, XFinder, XFlex, XFloatButton, XFooter, XForm, XFormBuilder, XFormItem, XHeader, XIcon, XImage, XInfiniteScroll, XInput, XInputNumber, XLayout, XList, XListItem, XMentions, XMenu, XMenuDivider, XMenuItem, XMenuItemGroup, XMenuSubmenu, XMessage, XModal, XModalContent, XNotification, XPageHeader, XPagination, XPopconfirm, XPopover, XProgress, XQrCode, XRadio, XRadioGroup, XRangePicker, XRangePickerDropdownContent, XRate, XResult, XRow, XSegmented, XSelect, XSelectDropdownContent, XSelectOption, XSider, XSkeleton, XSlider, XSpace, XSpin, XSplitter, XSplitterPanel, XStatistic, XStep, XSteps, XSwitch, XTabPane, XTable, XTableCell, XTableRow, XTabs, XTag, XTextarea, XTimePicker, XTimePickerDropdownContent, XTimeline, XTimelineItem, XTooltip, XTour, XTourPanel, XTransfer, XTree, XTreeSelect, XTreeSelectDropdownContent, XTypography, XUpload, XVirtualScroll, XWorkflow, XWorkflowBuilder, XTableDirective, XRowCell], imports: [CommonModule], exports: [XAddress, XAffix, XAlert, XAnchor, XAnchorLink, XApp, XAutoComplete, XAutoCompleteDropdownContent, XAvatar, XBackTop, XBadge, XBreadcrumb, XBreadcrumbItem, XButton, XCaptcha, XCard, XCarousel, XCascader, XCascaderDropdownContent, XCheckbox, XCol, XCollapse, XCollapsePanel, XColorPicker, XComment, XContent, XDatePicker, XDatePickerDropdownContent, XDescriptions, XDescriptionsItem, XDivider, XDrawer, XDrawerContent, XDropdown, XEditor, XEmpty, XFinder, XFlex, XFloatButton, XFooter, XForm, XFormBuilder, XFormItem, XHeader, XIcon, XImage, XInfiniteScroll, XInput, XInputNumber, XLayout, XList, XListItem, XMentions, XMenu, XMenuDivider, XMenuItem, XMenuItemGroup, XMenuSubmenu, XMessage, XModal, XModalContent, XNotification, XPageHeader, XPagination, XPopconfirm, XPopover, XProgress, XQrCode, XRadio, XRadioGroup, XRangePicker, XRangePickerDropdownContent, XRate, XResult, XRow, XSegmented, XSelect, XSelectDropdownContent, XSelectOption, XSider, XSkeleton, XSlider, XSpace, XSpin, XSplitter, XSplitterPanel, XStatistic, XStep, XSteps, XSwitch, XTabPane, XTable, XTableCell, XTableRow, XTabs, XTag, XTextarea, XTimePicker, XTimePickerDropdownContent, XTimeline, XTimelineItem, XTooltip, XTour, XTourPanel, XTransfer, XTree, XTreeSelect, XTreeSelectDropdownContent, XTypography, XUpload, XVirtualScroll, XWorkflow, XWorkflowBuilder, XTableDirective, XRowCell] }); })();
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { XAddress, XAffix, XAlert, XAnchor, XAnchorLink, XApp, XAutoComplete, XAutoCompleteDropdownContent, XAvatar, XBackTop, XBadge, XBreadcrumb, XBreadcrumbItem, XButton, XCaptcha, XCard, XCarousel, XCascader, XCascaderDropdownContent, XCheckbox, XCol, XCollapse, XCollapsePanel, XColorPicker, XComment, XContent, XDatePicker, XDatePickerDropdownContent, XDescriptions, XDescriptionsItem, XDivider, XDrawer, XDrawerContent, XDropdown, XEditor, XEmpty, XFinder, XFlex, XFloatButton, XFooter, XForm, XFormBuilder, XFormItem, XHeader, XIcon, XImage, XInfiniteScroll, XInput, XInputNumber, XLayout, XList, XListItem, XMentions, XMenu, XMenuDivider, XMenuItem, XMenuItemGroup, XMenuSubmenu, XMessage, XModal, XModalContent, XNotification, XPageHeader, XPagination, XPopconfirm, XPopover, XProgress, XQrCode, XRadio, XRadioGroup, XRangePicker, XRangePickerDropdownContent, XRate, XResult, XRow, XRowCell, XSegmented, XSelect, XSelectDropdownContent, XSelectOption, XSider, XSkeleton, XSlider, XSpace, XSpin, XSplitter, XSplitterPanel, XStatistic, XStep, XSteps, XSwitch, XTabPane, XTable, XTableCell, XTableDirective, XTableRow, XTabs, XTag, XTextarea, XTimePicker, XTimePickerDropdownContent, XTimeline, XTimelineItem, XTooltip, XTour, XTourPanel, XTransfer, XTree, XTreeSelect, XTreeSelectDropdownContent, XTypography, XUpload, XVirtualScroll, XWorkflow, XWorkflowBuilder, XlabsModule };
+//# sourceMappingURL=xlabs-store-angular.mjs.map