@xplortech/apollo-angular 3.2.1 → 3.4.0

package/dist/directives/proxies.js

@@ -86,6 +86,7 @@ import { defineCustomElement as defineXplTopNav } from '@xplortech/apollo-core/c
 import { defineCustomElement as defineXplTopNavItem } from '@xplortech/apollo-core/components/xpl-top-nav-item.js';
 import { defineCustomElement as defineXplTopNavMenu } from '@xplortech/apollo-core/components/xpl-top-nav-menu.js';
 import { defineCustomElement as defineXplUtilityBar } from '@xplortech/apollo-core/components/xpl-utility-bar.js';
+import * as i0 from "@angular/core";
 let XplAccordion = class XplAccordion {
     constructor(c, r, z) {
         this.z = z;
@@ -93,21 +94,27 @@ let XplAccordion = class XplAccordion {
         this.el = r.nativeElement;
     }
 };
+XplAccordion.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplAccordion.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplAccordion, isStandalone: true, selector: "xpl-accordion", inputs: { borderType: "borderType", contentId: "contentId", description: "description", header: "header", initialExpanded: "initialExpanded", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplAccordion = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplAccordion,
         inputs: ['borderType', 'contentId', 'description', 'header', 'initialExpanded', 'size'],
         methods: ['parentCheckboxChange']
     }),
-    Component({
-        selector: 'xpl-accordion',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['borderType', 'contentId', 'description', 'header', 'initialExpanded', 'size'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplAccordion);
 export { XplAccordion };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-accordion',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['borderType', 'contentId', 'description', 'header', 'initialExpanded', 'size'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplApplicationShell = class XplApplicationShell {
     constructor(c, r, z) {
         this.z = z;
@@ -115,20 +122,26 @@ let XplApplicationShell = class XplApplicationShell {
         this.el = r.nativeElement;
     }
 };
+XplApplicationShell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplApplicationShell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplApplicationShell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplApplicationShell, isStandalone: true, selector: "xpl-application-shell", inputs: { isNavOpenAtStartup: "isNavOpenAtStartup", navWidth: "navWidth", withSubnav: "withSubnav", withUtility: "withUtility" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplApplicationShell = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplApplicationShell,
         inputs: ['isNavOpenAtStartup', 'navWidth', 'withSubnav', 'withUtility']
     }),
-    Component({
-        selector: 'xpl-application-shell',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['isNavOpenAtStartup', 'navWidth', 'withSubnav', 'withUtility'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplApplicationShell);
 export { XplApplicationShell };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplApplicationShell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-application-shell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isNavOpenAtStartup', 'navWidth', 'withSubnav', 'withUtility'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplAvatar = class XplAvatar {
     constructor(c, r, z) {
         this.z = z;
@@ -136,20 +149,26 @@ let XplAvatar = class XplAvatar {
         this.el = r.nativeElement;
     }
 };
+XplAvatar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplAvatar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplAvatar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplAvatar, isStandalone: true, selector: "xpl-avatar", inputs: { color: "color", disabled: "disabled", groupData: "groupData", href: "href", name: "name", size: "size", src: "src", status: "status", subText: "subText", target: "target", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplAvatar = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplAvatar,
         inputs: ['color', 'disabled', 'groupData', 'href', 'name', 'size', 'src', 'status', 'subText', 'target', 'variant']
     }),
-    Component({
-        selector: 'xpl-avatar',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['color', 'disabled', 'groupData', 'href', 'name', 'size', 'src', 'status', 'subText', 'target', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplAvatar);
 export { XplAvatar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplAvatar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-avatar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['color', 'disabled', 'groupData', 'href', 'name', 'size', 'src', 'status', 'subText', 'target', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplBackdrop = class XplBackdrop {
     constructor(c, r, z) {
         this.z = z;
@@ -157,20 +176,26 @@ let XplBackdrop = class XplBackdrop {
         this.el = r.nativeElement;
     }
 };
+XplBackdrop.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBackdrop, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplBackdrop.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplBackdrop, isStandalone: true, selector: "xpl-backdrop", inputs: { relative: "relative" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplBackdrop = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplBackdrop,
         inputs: ['relative']
     }),
-    Component({
-        selector: 'xpl-backdrop',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['relative'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplBackdrop);
 export { XplBackdrop };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBackdrop, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-backdrop',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['relative'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplBadge = class XplBadge {
     constructor(c, r, z) {
         this.z = z;
@@ -178,20 +203,26 @@ let XplBadge = class XplBadge {
         this.el = r.nativeElement;
     }
 };
+XplBadge.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBadge, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplBadge.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplBadge, isStandalone: true, selector: "xpl-badge", inputs: { bordered: "bordered", dot: "dot", dotOnly: "dotOnly", shape: "shape", size: "size", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplBadge = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplBadge,
         inputs: ['bordered', 'dot', 'dotOnly', 'shape', 'size', 'variant']
     }),
-    Component({
-        selector: 'xpl-badge',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['bordered', 'dot', 'dotOnly', 'shape', 'size', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplBadge);
 export { XplBadge };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBadge, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-badge',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['bordered', 'dot', 'dotOnly', 'shape', 'size', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplBanner = class XplBanner {
     constructor(c, r, z) {
         this.z = z;
@@ -202,33 +233,33 @@ let XplBanner = class XplBanner {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplBanner.prototype, "action", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplBanner.prototype, "dismiss", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplBanner.prototype, "secondaryAction", void 0);
+XplBanner.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBanner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplBanner.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplBanner, isStandalone: true, selector: "xpl-banner", inputs: { actionText: "actionText", appearance: "appearance", description: "description", hasIcon: "hasIcon", heading: "heading", isDismissible: "isDismissible", isSection: "isSection", secondaryActionText: "secondaryActionText", truncateDesc: "truncateDesc" }, outputs: { action: "action", dismiss: "dismiss", secondaryAction: "secondaryAction" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplBanner = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplBanner,
         inputs: ['actionText', 'appearance', 'description', 'hasIcon', 'heading', 'isDismissible', 'isSection', 'secondaryActionText', 'truncateDesc']
     }),
-    Component({
-        selector: 'xpl-banner',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['actionText', 'appearance', 'description', 'hasIcon', 'heading', 'isDismissible', 'isSection', 'secondaryActionText', 'truncateDesc'],
-        outputs: ['action', 'dismiss', 'secondaryAction'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplBanner);
 export { XplBanner };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBanner, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-banner',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['actionText', 'appearance', 'description', 'hasIcon', 'heading', 'isDismissible', 'isSection', 'secondaryActionText', 'truncateDesc'],
+                    outputs: ['action', 'dismiss', 'secondaryAction'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { action: [{
+                type: Output
+            }], dismiss: [{
+                type: Output
+            }], secondaryAction: [{
+                type: Output
+            }] } });
 let XplBreadcrumbItem = class XplBreadcrumbItem {
     constructor(c, r, z) {
         this.z = z;
@@ -236,19 +267,25 @@ let XplBreadcrumbItem = class XplBreadcrumbItem {
         this.el = r.nativeElement;
     }
 };
+XplBreadcrumbItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBreadcrumbItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplBreadcrumbItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplBreadcrumbItem, isStandalone: true, selector: "xpl-breadcrumb-item", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplBreadcrumbItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplBreadcrumbItem
     }),
-    Component({
-        selector: 'xpl-breadcrumb-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplBreadcrumbItem);
 export { XplBreadcrumbItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBreadcrumbItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-breadcrumb-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplBreadcrumbs = class XplBreadcrumbs {
     constructor(c, r, z) {
         this.z = z;
@@ -256,19 +293,25 @@ let XplBreadcrumbs = class XplBreadcrumbs {
         this.el = r.nativeElement;
     }
 };
+XplBreadcrumbs.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBreadcrumbs, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplBreadcrumbs.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplBreadcrumbs, isStandalone: true, selector: "xpl-breadcrumbs", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplBreadcrumbs = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplBreadcrumbs
     }),
-    Component({
-        selector: 'xpl-breadcrumbs',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplBreadcrumbs);
 export { XplBreadcrumbs };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplBreadcrumbs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-breadcrumbs',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplButton = class XplButton {
     constructor(c, r, z) {
         this.z = z;
@@ -276,20 +319,26 @@ let XplButton = class XplButton {
         this.el = r.nativeElement;
     }
 };
+XplButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplButton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplButton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplButton, isStandalone: true, selector: "xpl-button", inputs: { controlAttrs: "controlAttrs", disabled: "disabled", form: "form", fullWidth: "fullWidth", icon: "icon", iconOnly: "iconOnly", iconPosition: "iconPosition", isLoading: "isLoading", link: "link", name: "name", sentiment: "sentiment", size: "size", state: "state", type: "type", value: "value", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplButton = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplButton,
         inputs: ['controlAttrs', 'disabled', 'form', 'fullWidth', 'icon', 'iconOnly', 'iconPosition', 'isLoading', 'link', 'name', 'sentiment', 'size', 'state', 'type', 'value', 'variant']
     }),
-    Component({
-        selector: 'xpl-button',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['controlAttrs', 'disabled', 'form', 'fullWidth', 'icon', 'iconOnly', 'iconPosition', 'isLoading', 'link', 'name', 'sentiment', 'size', 'state', 'type', 'value', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplButton);
 export { XplButton };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-button',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['controlAttrs', 'disabled', 'form', 'fullWidth', 'icon', 'iconOnly', 'iconPosition', 'isLoading', 'link', 'name', 'sentiment', 'size', 'state', 'type', 'value', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplButtonRow = class XplButtonRow {
     constructor(c, r, z) {
         this.z = z;
@@ -300,33 +349,33 @@ let XplButtonRow = class XplButtonRow {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplButtonRow.prototype, "clickPrimary", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplButtonRow.prototype, "clickSecondary", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplButtonRow.prototype, "clickTertiary", void 0);
+XplButtonRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplButtonRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplButtonRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplButtonRow, isStandalone: true, selector: "xpl-button-row", inputs: { primary: "primary", secondary: "secondary", tertiary: "tertiary" }, outputs: { clickPrimary: "clickPrimary", clickSecondary: "clickSecondary", clickTertiary: "clickTertiary" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplButtonRow = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplButtonRow,
         inputs: ['primary', 'secondary', 'tertiary']
     }),
-    Component({
-        selector: 'xpl-button-row',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['primary', 'secondary', 'tertiary'],
-        outputs: ['clickPrimary', 'clickSecondary', 'clickTertiary'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplButtonRow);
 export { XplButtonRow };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplButtonRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-button-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['primary', 'secondary', 'tertiary'],
+                    outputs: ['clickPrimary', 'clickSecondary', 'clickTertiary'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { clickPrimary: [{
+                type: Output
+            }], clickSecondary: [{
+                type: Output
+            }], clickTertiary: [{
+                type: Output
+            }] } });
 let XplCalendar = class XplCalendar {
     constructor(c, r, z) {
         this.z = z;
@@ -335,26 +384,30 @@ let XplCalendar = class XplCalendar {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplCalendar.prototype, "dateSelected", void 0);
+XplCalendar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplCalendar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplCalendar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplCalendar, isStandalone: true, selector: "xpl-calendar", inputs: { dateFormat: "dateFormat", defaultDate: "defaultDate", inputId: "inputId", max: "max", min: "min", mode: "mode" }, outputs: { dateSelected: "dateSelected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplCalendar = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplCalendar,
         inputs: ['dateFormat', 'defaultDate', 'inputId', 'max', 'min', 'mode'],
         methods: ['setDate']
     }),
-    Component({
-        selector: 'xpl-calendar',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['dateFormat', 'defaultDate', 'inputId', 'max', 'min', 'mode'],
-        outputs: ['dateSelected'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplCalendar);
 export { XplCalendar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplCalendar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-calendar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['dateFormat', 'defaultDate', 'inputId', 'max', 'min', 'mode'],
+                    outputs: ['dateSelected'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { dateSelected: [{
+                type: Output
+            }] } });
 let XplCheckbox = class XplCheckbox {
     constructor(c, r, z) {
         this.z = z;
@@ -363,25 +416,29 @@ let XplCheckbox = class XplCheckbox {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplCheckbox.prototype, "checkboxChange", void 0);
+XplCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplCheckbox, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplCheckbox.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplCheckbox, isStandalone: true, selector: "xpl-checkbox", inputs: { ariaLabel: "ariaLabel", checked: "checked", dataId: "dataId", description: "description", disabled: "disabled", indeterminate: "indeterminate", name: "name", required: "required", styled: "styled", value: "value" }, outputs: { checkboxChange: "checkboxChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplCheckbox = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplCheckbox,
         inputs: ['ariaLabel', 'checked', 'dataId', 'description', 'disabled', 'indeterminate', 'name', 'required', 'styled', 'value']
     }),
-    Component({
-        selector: 'xpl-checkbox',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['ariaLabel', 'checked', 'dataId', 'description', 'disabled', 'indeterminate', 'name', 'required', 'styled', 'value'],
-        outputs: ['checkboxChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplCheckbox);
 export { XplCheckbox };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplCheckbox, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-checkbox',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['ariaLabel', 'checked', 'dataId', 'description', 'disabled', 'indeterminate', 'name', 'required', 'styled', 'value'],
+                    outputs: ['checkboxChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { checkboxChange: [{
+                type: Output
+            }] } });
 let XplChoicelist = class XplChoicelist {
     constructor(c, r, z) {
         this.z = z;
@@ -391,29 +448,31 @@ let XplChoicelist = class XplChoicelist {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplChoicelist.prototype, "choicelistChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplChoicelist.prototype, "choicelistValueChange", void 0);
+XplChoicelist.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplChoicelist, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplChoicelist.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplChoicelist, isStandalone: true, selector: "xpl-choicelist", inputs: { choices: "choices", description: "description", heading: "heading", multi: "multi", name: "name", styled: "styled" }, outputs: { choicelistChange: "choicelistChange", choicelistValueChange: "choicelistValueChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplChoicelist = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplChoicelist,
         inputs: ['choices', 'description', 'heading', 'multi', 'name', 'styled']
     }),
-    Component({
-        selector: 'xpl-choicelist',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['choices', 'description', 'heading', 'multi', 'name', 'styled'],
-        outputs: ['choicelistChange', 'choicelistValueChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplChoicelist);
 export { XplChoicelist };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplChoicelist, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-choicelist',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['choices', 'description', 'heading', 'multi', 'name', 'styled'],
+                    outputs: ['choicelistChange', 'choicelistValueChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { choicelistChange: [{
+                type: Output
+            }], choicelistValueChange: [{
+                type: Output
+            }] } });
 let XplContentArea = class XplContentArea {
     constructor(c, r, z) {
         this.z = z;
@@ -421,20 +480,26 @@ let XplContentArea = class XplContentArea {
         this.el = r.nativeElement;
     }
 };
+XplContentArea.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplContentArea, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplContentArea.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplContentArea, isStandalone: true, selector: "xpl-content-area", inputs: { size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplContentArea = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplContentArea,
         inputs: ['size']
     }),
-    Component({
-        selector: 'xpl-content-area',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['size'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplContentArea);
 export { XplContentArea };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplContentArea, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-content-area',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['size'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDashboard = class XplDashboard {
     constructor(c, r, z) {
         this.z = z;
@@ -442,19 +507,25 @@ let XplDashboard = class XplDashboard {
         this.el = r.nativeElement;
     }
 };
+XplDashboard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDashboard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDashboard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDashboard, isStandalone: true, selector: "xpl-dashboard", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDashboard = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDashboard
     }),
-    Component({
-        selector: 'xpl-dashboard',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDashboard);
 export { XplDashboard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDashboard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dashboard',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDataCard = class XplDataCard {
     constructor(c, r, z) {
         this.z = z;
@@ -462,20 +533,26 @@ let XplDataCard = class XplDataCard {
         this.el = r.nativeElement;
     }
 };
+XplDataCard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDataCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDataCard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDataCard, isStandalone: true, selector: "xpl-data-card", inputs: { detail: "detail", icon: "icon", leadingIcon: "leadingIcon", link: "link", name: "name", shortStat: "shortStat", smallStat: "smallStat", smallStatIcon: "smallStatIcon", smallStatVariant: "smallStatVariant", stat: "stat", tooltipTextSmallStat: "tooltipTextSmallStat", tooltipTextStat: "tooltipTextStat", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDataCard = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDataCard,
         inputs: ['detail', 'icon', 'leadingIcon', 'link', 'name', 'shortStat', 'smallStat', 'smallStatIcon', 'smallStatVariant', 'stat', 'tooltipTextSmallStat', 'tooltipTextStat', 'variant']
     }),
-    Component({
-        selector: 'xpl-data-card',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['detail', 'icon', 'leadingIcon', 'link', 'name', 'shortStat', 'smallStat', 'smallStatIcon', 'smallStatVariant', 'stat', 'tooltipTextSmallStat', 'tooltipTextStat', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDataCard);
 export { XplDataCard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDataCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-data-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['detail', 'icon', 'leadingIcon', 'link', 'name', 'shortStat', 'smallStat', 'smallStatIcon', 'smallStatVariant', 'stat', 'tooltipTextSmallStat', 'tooltipTextStat', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDivider = class XplDivider {
     constructor(c, r, z) {
         this.z = z;
@@ -483,20 +560,26 @@ let XplDivider = class XplDivider {
         this.el = r.nativeElement;
     }
 };
+XplDivider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDivider.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDivider, isStandalone: true, selector: "xpl-divider", inputs: { tier: "tier" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDivider = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDivider,
         inputs: ['tier']
     }),
-    Component({
-        selector: 'xpl-divider',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['tier'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDivider);
 export { XplDivider };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['tier'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDropdown = class XplDropdown {
     constructor(c, r, z) {
         this.z = z;
@@ -505,26 +588,30 @@ let XplDropdown = class XplDropdown {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplDropdown.prototype, "isOpenChange", void 0);
+XplDropdown.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDropdown.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDropdown, isStandalone: true, selector: "xpl-dropdown", inputs: { anchorToTrigger: "anchorToTrigger", closeOnSelect: "closeOnSelect", flipFallbackPlacements: "flipFallbackPlacements", isOpen: "isOpen", mode: "mode", options: "options", placement: "placement", selectOnFocus: "selectOnFocus", selectedValues: "selectedValues", triggerId: "triggerId", update: "update" }, outputs: { isOpenChange: "isOpenChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDropdown = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDropdown,
         inputs: ['anchorToTrigger', 'closeOnSelect', 'flipFallbackPlacements', 'isOpen', 'mode', 'options', 'placement', 'selectOnFocus', 'selectedValues', 'triggerId', 'update'],
         methods: ['handleSelect']
     }),
-    Component({
-        selector: 'xpl-dropdown',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['anchorToTrigger', 'closeOnSelect', 'flipFallbackPlacements', 'isOpen', 'mode', 'options', 'placement', 'selectOnFocus', 'selectedValues', 'triggerId', 'update'],
-        outputs: ['isOpenChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDropdown);
 export { XplDropdown };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dropdown',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['anchorToTrigger', 'closeOnSelect', 'flipFallbackPlacements', 'isOpen', 'mode', 'options', 'placement', 'selectOnFocus', 'selectedValues', 'triggerId', 'update'],
+                    outputs: ['isOpenChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { isOpenChange: [{
+                type: Output
+            }] } });
 let XplDropdownGroup = class XplDropdownGroup {
     constructor(c, r, z) {
         this.z = z;
@@ -532,20 +619,26 @@ let XplDropdownGroup = class XplDropdownGroup {
         this.el = r.nativeElement;
     }
 };
+XplDropdownGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDropdownGroup.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDropdownGroup, isStandalone: true, selector: "xpl-dropdown-group", inputs: { groupName: "groupName", options: "options" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDropdownGroup = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDropdownGroup,
         inputs: ['groupName', 'options']
     }),
-    Component({
-        selector: 'xpl-dropdown-group',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['groupName', 'options'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDropdownGroup);
 export { XplDropdownGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownGroup, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dropdown-group',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['groupName', 'options'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDropdownHeading = class XplDropdownHeading {
     constructor(c, r, z) {
         this.z = z;
@@ -553,20 +646,26 @@ let XplDropdownHeading = class XplDropdownHeading {
         this.el = r.nativeElement;
     }
 };
+XplDropdownHeading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownHeading, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDropdownHeading.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDropdownHeading, isStandalone: true, selector: "xpl-dropdown-heading", inputs: { label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDropdownHeading = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDropdownHeading,
         inputs: ['label']
     }),
-    Component({
-        selector: 'xpl-dropdown-heading',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['label'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDropdownHeading);
 export { XplDropdownHeading };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownHeading, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dropdown-heading',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['label'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDropdownOption = class XplDropdownOption {
     constructor(c, r, z) {
         this.z = z;
@@ -574,20 +673,26 @@ let XplDropdownOption = class XplDropdownOption {
         this.el = r.nativeElement;
     }
 };
+XplDropdownOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownOption, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDropdownOption.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDropdownOption, isStandalone: true, selector: "xpl-dropdown-option", inputs: { icon: "icon", isDisabled: "isDisabled", isSelected: "isSelected", label: "label", subtitle: "subtitle", value: "value" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDropdownOption = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDropdownOption,
         inputs: ['icon', 'isDisabled', 'isSelected', 'label', 'subtitle', 'value']
     }),
-    Component({
-        selector: 'xpl-dropdown-option',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['icon', 'isDisabled', 'isSelected', 'label', 'subtitle', 'value'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDropdownOption);
 export { XplDropdownOption };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDropdownOption, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dropdown-option',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['icon', 'isDisabled', 'isSelected', 'label', 'subtitle', 'value'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDynamicTable = class XplDynamicTable {
     constructor(c, r, z) {
         this.z = z;
@@ -596,24 +701,28 @@ let XplDynamicTable = class XplDynamicTable {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplDynamicTable.prototype, "selectedItemCountChange", void 0);
+XplDynamicTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTable, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDynamicTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDynamicTable, isStandalone: true, selector: "xpl-dynamic-table", outputs: { selectedItemCountChange: "selectedItemCountChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDynamicTable = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDynamicTable
     }),
-    Component({
-        selector: 'xpl-dynamic-table',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-        outputs: ['selectedItemCountChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDynamicTable);
 export { XplDynamicTable };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTable, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dynamic-table',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                    outputs: ['selectedItemCountChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { selectedItemCountChange: [{
+                type: Output
+            }] } });
 let XplDynamicTableCell = class XplDynamicTableCell {
     constructor(c, r, z) {
         this.z = z;
@@ -621,20 +730,26 @@ let XplDynamicTableCell = class XplDynamicTableCell {
         this.el = r.nativeElement;
     }
 };
+XplDynamicTableCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTableCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDynamicTableCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDynamicTableCell, isStandalone: true, selector: "xpl-dynamic-table-cell", inputs: { disabled: "disabled" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDynamicTableCell = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDynamicTableCell,
         inputs: ['disabled']
     }),
-    Component({
-        selector: 'xpl-dynamic-table-cell',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDynamicTableCell);
 export { XplDynamicTableCell };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTableCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dynamic-table-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplDynamicTableRow = class XplDynamicTableRow {
     constructor(c, r, z) {
         this.z = z;
@@ -642,20 +757,26 @@ let XplDynamicTableRow = class XplDynamicTableRow {
         this.el = r.nativeElement;
     }
 };
+XplDynamicTableRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTableRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplDynamicTableRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplDynamicTableRow, isStandalone: true, selector: "xpl-dynamic-table-row", inputs: { disabled: "disabled", selected: "selected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplDynamicTableRow = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplDynamicTableRow,
         inputs: ['disabled', 'selected']
     }),
-    Component({
-        selector: 'xpl-dynamic-table-row',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'selected'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplDynamicTableRow);
 export { XplDynamicTableRow };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplDynamicTableRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-dynamic-table-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'selected'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplGrid = class XplGrid {
     constructor(c, r, z) {
         this.z = z;
@@ -663,19 +784,25 @@ let XplGrid = class XplGrid {
         this.el = r.nativeElement;
     }
 };
+XplGrid.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplGrid, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplGrid.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplGrid, isStandalone: true, selector: "xpl-grid", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplGrid = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplGrid
     }),
-    Component({
-        selector: 'xpl-grid',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplGrid);
 export { XplGrid };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplGrid, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-grid',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplGridItem = class XplGridItem {
     constructor(c, r, z) {
         this.z = z;
@@ -683,20 +810,26 @@ let XplGridItem = class XplGridItem {
         this.el = r.nativeElement;
     }
 };
+XplGridItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplGridItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplGridItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplGridItem, isStandalone: true, selector: "xpl-grid-item", inputs: { lg: "lg", md: "md", sm: "sm", xs: "xs" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplGridItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplGridItem,
         inputs: ['lg', 'md', 'sm', 'xs']
     }),
-    Component({
-        selector: 'xpl-grid-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['lg', 'md', 'sm', 'xs'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplGridItem);
 export { XplGridItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplGridItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-grid-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['lg', 'md', 'sm', 'xs'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplHeaderAccordion = class XplHeaderAccordion {
     constructor(c, r, z) {
         this.z = z;
@@ -704,20 +837,26 @@ let XplHeaderAccordion = class XplHeaderAccordion {
         this.el = r.nativeElement;
     }
 };
+XplHeaderAccordion.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplHeaderAccordion, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplHeaderAccordion.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplHeaderAccordion, isStandalone: true, selector: "xpl-header-accordion", inputs: { contentId: "contentId", disabled: "disabled", hasCheckbox: "hasCheckbox", initialExpanded: "initialExpanded", selectedCount: "selectedCount" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplHeaderAccordion = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplHeaderAccordion,
         inputs: ['contentId', 'disabled', 'hasCheckbox', 'initialExpanded', 'selectedCount']
     }),
-    Component({
-        selector: 'xpl-header-accordion',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['contentId', 'disabled', 'hasCheckbox', 'initialExpanded', 'selectedCount'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplHeaderAccordion);
 export { XplHeaderAccordion };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplHeaderAccordion, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-header-accordion',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['contentId', 'disabled', 'hasCheckbox', 'initialExpanded', 'selectedCount'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplIcon = class XplIcon {
     constructor(c, r, z) {
         this.z = z;
@@ -725,20 +864,26 @@ let XplIcon = class XplIcon {
         this.el = r.nativeElement;
     }
 };
+XplIcon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplIcon.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplIcon, isStandalone: true, selector: "xpl-icon", inputs: { backgroundColor: "backgroundColor", icon: "icon", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplIcon = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplIcon,
         inputs: ['backgroundColor', 'icon', 'size']
     }),
-    Component({
-        selector: 'xpl-icon',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['backgroundColor', { name: 'icon', required: true }, 'size'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplIcon);
 export { XplIcon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplIcon, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-icon',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['backgroundColor', { name: 'icon', required: true }, 'size'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplInput = class XplInput {
     constructor(c, r, z) {
         this.z = z;
@@ -751,42 +896,38 @@ let XplInput = class XplInput {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInput.prototype, "blurEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInput.prototype, "focusEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInput.prototype, "inputEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInput.prototype, "search", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInput.prototype, "valueChange", void 0);
+XplInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInput, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInput.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInput, isStandalone: true, selector: "xpl-input", inputs: { _id: "_id", accept: "accept", allowCustomOption: "allowCustomOption", ariaLabel: "ariaLabel", autocomplete: "autocomplete", dateFormat: "dateFormat", defaultCountry: "defaultCountry", description: "description", disabled: "disabled", error: "error", hideAcceptText: "hideAcceptText", hideEyeDropper: "hideEyeDropper", hideFileNames: "hideFileNames", hideTriggerOnSelect: "hideTriggerOnSelect", isInternational: "isInternational", label: "label", max: "max", maxCharacterCount: "maxCharacterCount", min: "min", mode: "mode", multiline: "multiline", multiple: "multiple", name: "name", placeholder: "placeholder", post: "post", pre: "pre", preferredCountries: "preferredCountries", readonly: "readonly", required: "required", shape: "shape", step: "step", timeFormat: "timeFormat", type: "type", value: "value" }, outputs: { blurEvent: "blurEvent", focusEvent: "focusEvent", inputEvent: "inputEvent", search: "search", valueChange: "valueChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInput = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInput,
         inputs: ['_id', 'accept', 'allowCustomOption', 'ariaLabel', 'autocomplete', 'dateFormat', 'defaultCountry', 'description', 'disabled', 'error', 'hideAcceptText', 'hideEyeDropper', 'hideFileNames', 'hideTriggerOnSelect', 'isInternational', 'label', 'max', 'maxCharacterCount', 'min', 'mode', 'multiline', 'multiple', 'name', 'placeholder', 'post', 'pre', 'preferredCountries', 'readonly', 'required', 'shape', 'step', 'timeFormat', 'type', 'value'],
         methods: ['setFocus']
     }),
-    Component({
-        selector: 'xpl-input',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['_id', 'accept', 'allowCustomOption', 'ariaLabel', 'autocomplete', 'dateFormat', 'defaultCountry', 'description', 'disabled', 'error', 'hideAcceptText', 'hideEyeDropper', 'hideFileNames', 'hideTriggerOnSelect', 'isInternational', 'label', 'max', 'maxCharacterCount', 'min', 'mode', 'multiline', 'multiple', 'name', 'placeholder', 'post', 'pre', 'preferredCountries', 'readonly', 'required', 'shape', 'step', 'timeFormat', 'type', 'value'],
-        outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInput);
 export { XplInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['_id', 'accept', 'allowCustomOption', 'ariaLabel', 'autocomplete', 'dateFormat', 'defaultCountry', 'description', 'disabled', 'error', 'hideAcceptText', 'hideEyeDropper', 'hideFileNames', 'hideTriggerOnSelect', 'isInternational', 'label', 'max', 'maxCharacterCount', 'min', 'mode', 'multiline', 'multiple', 'name', 'placeholder', 'post', 'pre', 'preferredCountries', 'readonly', 'required', 'shape', 'step', 'timeFormat', 'type', 'value'],
+                    outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { blurEvent: [{
+                type: Output
+            }], focusEvent: [{
+                type: Output
+            }], inputEvent: [{
+                type: Output
+            }], search: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }] } });
 let XplInputColor = class XplInputColor {
     constructor(c, r, z) {
         this.z = z;
@@ -796,29 +937,31 @@ let XplInputColor = class XplInputColor {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputColor.prototype, "inputChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputColor.prototype, "hasErrorStateChanged", void 0);
+XplInputColor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputColor, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputColor.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputColor, isStandalone: true, selector: "xpl-input-color", inputs: { disabled: "disabled", hideEyeDropper: "hideEyeDropper", placeholder: "placeholder", required: "required", value: "value" }, outputs: { inputChange: "inputChange", hasErrorStateChanged: "hasErrorStateChanged" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputColor = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputColor,
         inputs: ['disabled', 'hideEyeDropper', 'placeholder', 'required', 'value']
     }),
-    Component({
-        selector: 'xpl-input-color',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'hideEyeDropper', 'placeholder', 'required', 'value'],
-        outputs: ['inputChange', 'hasErrorStateChanged'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputColor);
 export { XplInputColor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputColor, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-color',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'hideEyeDropper', 'placeholder', 'required', 'value'],
+                    outputs: ['inputChange', 'hasErrorStateChanged'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { inputChange: [{
+                type: Output
+            }], hasErrorStateChanged: [{
+                type: Output
+            }] } });
 let XplInputDate = class XplInputDate {
     constructor(c, r, z) {
         this.z = z;
@@ -829,33 +972,33 @@ let XplInputDate = class XplInputDate {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputDate.prototype, "valueChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputDate.prototype, "hasErrorStateChanged", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputDate.prototype, "rangeSelected", void 0);
+XplInputDate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputDate, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputDate.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputDate, isStandalone: true, selector: "xpl-input-date", inputs: { dateFormat: "dateFormat", disabled: "disabled", inputId: "inputId", max: "max", min: "min", mode: "mode", name: "name", placeholder: "placeholder", post: "post", pre: "pre", readonly: "readonly", required: "required", value: "value" }, outputs: { valueChange: "valueChange", hasErrorStateChanged: "hasErrorStateChanged", rangeSelected: "rangeSelected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputDate = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputDate,
         inputs: ['dateFormat', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'post', 'pre', 'readonly', 'required', 'value']
     }),
-    Component({
-        selector: 'xpl-input-date',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['dateFormat', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'post', 'pre', 'readonly', 'required', 'value'],
-        outputs: ['valueChange', 'hasErrorStateChanged', 'rangeSelected'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputDate);
 export { XplInputDate };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputDate, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-date',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['dateFormat', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'post', 'pre', 'readonly', 'required', 'value'],
+                    outputs: ['valueChange', 'hasErrorStateChanged', 'rangeSelected'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { valueChange: [{
+                type: Output
+            }], hasErrorStateChanged: [{
+                type: Output
+            }], rangeSelected: [{
+                type: Output
+            }] } });
 let XplInputFile = class XplInputFile {
     constructor(c, r, z) {
         this.z = z;
@@ -864,26 +1007,30 @@ let XplInputFile = class XplInputFile {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputFile.prototype, "inputChange", void 0);
+XplInputFile.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputFile, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputFile.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputFile, isStandalone: true, selector: "xpl-input-file", inputs: { _id: "_id", accept: "accept", disabled: "disabled", hideAcceptText: "hideAcceptText", hideFileNames: "hideFileNames", hideTriggerOnSelect: "hideTriggerOnSelect", multiple: "multiple", name: "name" }, outputs: { inputChange: "inputChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputFile = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputFile,
         inputs: ['_id', 'accept', 'disabled', 'hideAcceptText', 'hideFileNames', 'hideTriggerOnSelect', 'multiple', 'name'],
         methods: ['removeFileByIndex']
     }),
-    Component({
-        selector: 'xpl-input-file',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['_id', 'accept', 'disabled', 'hideAcceptText', 'hideFileNames', 'hideTriggerOnSelect', 'multiple', 'name'],
-        outputs: ['inputChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputFile);
 export { XplInputFile };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputFile, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-file',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['_id', 'accept', 'disabled', 'hideAcceptText', 'hideFileNames', 'hideTriggerOnSelect', 'multiple', 'name'],
+                    outputs: ['inputChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { inputChange: [{
+                type: Output
+            }] } });
 let XplInputPhone = class XplInputPhone {
     constructor(c, r, z) {
         this.z = z;
@@ -893,29 +1040,31 @@ let XplInputPhone = class XplInputPhone {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputPhone.prototype, "hasErrorStateChanged", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputPhone.prototype, "valueChange", void 0);
+XplInputPhone.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputPhone, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputPhone.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputPhone, isStandalone: true, selector: "xpl-input-phone", inputs: { defaultCountry: "defaultCountry", disabled: "disabled", error: "error", inputId: "inputId", isInternational: "isInternational", name: "name", placeholder: "placeholder", preferredCountries: "preferredCountries", readonly: "readonly", required: "required", value: "value" }, outputs: { hasErrorStateChanged: "hasErrorStateChanged", valueChange: "valueChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputPhone = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputPhone,
         inputs: ['defaultCountry', 'disabled', 'error', 'inputId', 'isInternational', 'name', 'placeholder', 'preferredCountries', 'readonly', 'required', 'value']
     }),
-    Component({
-        selector: 'xpl-input-phone',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['defaultCountry', 'disabled', 'error', 'inputId', 'isInternational', 'name', 'placeholder', 'preferredCountries', 'readonly', 'required', 'value'],
-        outputs: ['hasErrorStateChanged', 'valueChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputPhone);
 export { XplInputPhone };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputPhone, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-phone',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['defaultCountry', 'disabled', 'error', 'inputId', 'isInternational', 'name', 'placeholder', 'preferredCountries', 'readonly', 'required', 'value'],
+                    outputs: ['hasErrorStateChanged', 'valueChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { hasErrorStateChanged: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }] } });
 let XplInputSearch = class XplInputSearch {
     constructor(c, r, z) {
         this.z = z;
@@ -928,42 +1077,38 @@ let XplInputSearch = class XplInputSearch {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputSearch.prototype, "blurEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputSearch.prototype, "focusEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputSearch.prototype, "inputEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputSearch.prototype, "search", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputSearch.prototype, "valueChange", void 0);
+XplInputSearch.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputSearch, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputSearch.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputSearch, isStandalone: true, selector: "xpl-input-search", inputs: { ariaLabel: "ariaLabel", autocomplete: "autocomplete", disabled: "disabled", errorMessageId: "errorMessageId", hasError: "hasError", hasVisibleLabel: "hasVisibleLabel", inputId: "inputId", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", shape: "shape", value: "value" }, outputs: { blurEvent: "blurEvent", focusEvent: "focusEvent", inputEvent: "inputEvent", search: "search", valueChange: "valueChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputSearch = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputSearch,
         inputs: ['ariaLabel', 'autocomplete', 'disabled', 'errorMessageId', 'hasError', 'hasVisibleLabel', 'inputId', 'name', 'placeholder', 'readonly', 'required', 'shape', 'value'],
         methods: ['setFocus']
     }),
-    Component({
-        selector: 'xpl-input-search',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['ariaLabel', 'autocomplete', 'disabled', 'errorMessageId', 'hasError', 'hasVisibleLabel', { name: 'inputId', required: true }, 'name', 'placeholder', 'readonly', 'required', 'shape', 'value'],
-        outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputSearch);
 export { XplInputSearch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputSearch, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-search',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['ariaLabel', 'autocomplete', 'disabled', 'errorMessageId', 'hasError', 'hasVisibleLabel', { name: 'inputId', required: true }, 'name', 'placeholder', 'readonly', 'required', 'shape', 'value'],
+                    outputs: ['blurEvent', 'focusEvent', 'inputEvent', 'search', 'valueChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { blurEvent: [{
+                type: Output
+            }], focusEvent: [{
+                type: Output
+            }], inputEvent: [{
+                type: Output
+            }], search: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }] } });
 let XplInputTime = class XplInputTime {
     constructor(c, r, z) {
         this.z = z;
@@ -973,29 +1118,31 @@ let XplInputTime = class XplInputTime {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputTime.prototype, "valueChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplInputTime.prototype, "hasErrorStateChanged", void 0);
+XplInputTime.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputTime, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplInputTime.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplInputTime, isStandalone: true, selector: "xpl-input-time", inputs: { allowCustomOption: "allowCustomOption", disabled: "disabled", inputId: "inputId", max: "max", min: "min", mode: "mode", name: "name", placeholder: "placeholder", readonly: "readonly", required: "required", step: "step", timeFormat: "timeFormat", value: "value" }, outputs: { valueChange: "valueChange", hasErrorStateChanged: "hasErrorStateChanged" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplInputTime = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplInputTime,
         inputs: ['allowCustomOption', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'readonly', 'required', 'step', 'timeFormat', 'value']
     }),
-    Component({
-        selector: 'xpl-input-time',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['allowCustomOption', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'readonly', 'required', 'step', 'timeFormat', 'value'],
-        outputs: ['valueChange', 'hasErrorStateChanged'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplInputTime);
 export { XplInputTime };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplInputTime, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-input-time',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['allowCustomOption', 'disabled', 'inputId', 'max', 'min', 'mode', 'name', 'placeholder', 'readonly', 'required', 'step', 'timeFormat', 'value'],
+                    outputs: ['valueChange', 'hasErrorStateChanged'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { valueChange: [{
+                type: Output
+            }], hasErrorStateChanged: [{
+                type: Output
+            }] } });
 let XplLargeCard = class XplLargeCard {
     constructor(c, r, z) {
         this.z = z;
@@ -1003,20 +1150,26 @@ let XplLargeCard = class XplLargeCard {
         this.el = r.nativeElement;
     }
 };
+XplLargeCard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplLargeCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplLargeCard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplLargeCard, isStandalone: true, selector: "xpl-large-card", inputs: { description: "description", link: "link", name: "name" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplLargeCard = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplLargeCard,
         inputs: ['description', 'link', 'name']
     }),
-    Component({
-        selector: 'xpl-large-card',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['description', 'link', 'name'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplLargeCard);
 export { XplLargeCard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplLargeCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-large-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['description', 'link', 'name'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplList = class XplList {
     constructor(c, r, z) {
         this.z = z;
@@ -1026,30 +1179,32 @@ let XplList = class XplList {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplList.prototype, "itemSelect", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplList.prototype, "orderChange", void 0);
+XplList.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplList.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplList, isStandalone: true, selector: "xpl-list", inputs: { items: "items", label: "label", labelledBy: "labelledBy", reorderable: "reorderable", selectable: "selectable" }, outputs: { itemSelect: "itemSelect", orderChange: "orderChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplList = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplList,
         inputs: ['items', 'label', 'labelledBy', 'reorderable', 'selectable'],
         methods: ['clearSelection']
     }),
-    Component({
-        selector: 'xpl-list',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['items', 'label', 'labelledBy', 'reorderable', 'selectable'],
-        outputs: ['itemSelect', 'orderChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplList);
 export { XplList };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['items', 'label', 'labelledBy', 'reorderable', 'selectable'],
+                    outputs: ['itemSelect', 'orderChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { itemSelect: [{
+                type: Output
+            }], orderChange: [{
+                type: Output
+            }] } });
 let XplListItem = class XplListItem {
     constructor(c, r, z) {
         this.z = z;
@@ -1061,37 +1216,35 @@ let XplListItem = class XplListItem {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplListItem.prototype, "itemDragEnd", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplListItem.prototype, "itemDragStart", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplListItem.prototype, "itemDrop", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplListItem.prototype, "itemSelect", void 0);
+XplListItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplListItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplListItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplListItem, isStandalone: true, selector: "xpl-list-item", inputs: { disabled: "disabled", error: "error", hidden: "hidden", href: "href", item: "item", itemId: "itemId", keyboardActive: "keyboardActive", radioName: "radioName", reorderable: "reorderable", selectable: "selectable", selected: "selected", showDivider: "showDivider", titleBadgeVariant: "titleBadgeVariant" }, outputs: { itemDragEnd: "itemDragEnd", itemDragStart: "itemDragStart", itemDrop: "itemDrop", itemSelect: "itemSelect" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplListItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplListItem,
         inputs: ['disabled', 'error', 'hidden', 'href', 'item', 'itemId', 'keyboardActive', 'radioName', 'reorderable', 'selectable', 'selected', 'showDivider', 'titleBadgeVariant']
     }),
-    Component({
-        selector: 'xpl-list-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'error', 'hidden', 'href', 'item', 'itemId', 'keyboardActive', 'radioName', 'reorderable', 'selectable', 'selected', 'showDivider', 'titleBadgeVariant'],
-        outputs: ['itemDragEnd', 'itemDragStart', 'itemDrop', 'itemSelect'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplListItem);
 export { XplListItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplListItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-list-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'error', 'hidden', 'href', 'item', 'itemId', 'keyboardActive', 'radioName', 'reorderable', 'selectable', 'selected', 'showDivider', 'titleBadgeVariant'],
+                    outputs: ['itemDragEnd', 'itemDragStart', 'itemDrop', 'itemSelect'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { itemDragEnd: [{
+                type: Output
+            }], itemDragStart: [{
+                type: Output
+            }], itemDrop: [{
+                type: Output
+            }], itemSelect: [{
+                type: Output
+            }] } });
 let XplMainNav = class XplMainNav {
     constructor(c, r, z) {
         this.z = z;
@@ -1100,25 +1253,29 @@ let XplMainNav = class XplMainNav {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplMainNav.prototype, "navWidth", void 0);
+XplMainNav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplMainNav, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplMainNav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplMainNav, isStandalone: true, selector: "xpl-main-nav", inputs: { width: "width" }, outputs: { navWidth: "navWidth" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplMainNav = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplMainNav,
         inputs: ['width']
     }),
-    Component({
-        selector: 'xpl-main-nav',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['width'],
-        outputs: ['navWidth'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplMainNav);
 export { XplMainNav };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplMainNav, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-main-nav',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['width'],
+                    outputs: ['navWidth'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { navWidth: [{
+                type: Output
+            }] } });
 let XplModal = class XplModal {
     constructor(c, r, z) {
         this.z = z;
@@ -1127,25 +1284,29 @@ let XplModal = class XplModal {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplModal.prototype, "modalClosed", void 0);
+XplModal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplModal, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplModal.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplModal, isStandalone: true, selector: "xpl-modal", inputs: { isOpen: "isOpen", size: "size", variant: "variant" }, outputs: { modalClosed: "modalClosed" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplModal = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplModal,
         inputs: ['isOpen', 'size', 'variant']
     }),
-    Component({
-        selector: 'xpl-modal',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['isOpen', 'size', 'variant'],
-        outputs: ['modalClosed'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplModal);
 export { XplModal };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplModal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-modal',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isOpen', 'size', 'variant'],
+                    outputs: ['modalClosed'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { modalClosed: [{
+                type: Output
+            }] } });
 let XplNavHeaderMenu = class XplNavHeaderMenu {
     constructor(c, r, z) {
         this.z = z;
@@ -1153,20 +1314,26 @@ let XplNavHeaderMenu = class XplNavHeaderMenu {
         this.el = r.nativeElement;
     }
 };
+XplNavHeaderMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplNavHeaderMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplNavHeaderMenu.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplNavHeaderMenu, isStandalone: true, selector: "xpl-nav-header-menu", inputs: { email: "email", username: "username" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplNavHeaderMenu = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplNavHeaderMenu,
         inputs: ['email', 'username']
     }),
-    Component({
-        selector: 'xpl-nav-header-menu',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['email', 'username'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplNavHeaderMenu);
 export { XplNavHeaderMenu };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplNavHeaderMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-nav-header-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['email', 'username'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplNavItem = class XplNavItem {
     constructor(c, r, z) {
         this.z = z;
@@ -1175,25 +1342,29 @@ let XplNavItem = class XplNavItem {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplNavItem.prototype, "navOpen", void 0);
+XplNavItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplNavItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplNavItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplNavItem, isStandalone: true, selector: "xpl-nav-item", inputs: { navControl: "navControl" }, outputs: { navOpen: "navOpen" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplNavItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplNavItem,
         inputs: ['navControl']
     }),
-    Component({
-        selector: 'xpl-nav-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['navControl'],
-        outputs: ['navOpen'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplNavItem);
 export { XplNavItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplNavItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-nav-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['navControl'],
+                    outputs: ['navOpen'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { navOpen: [{
+                type: Output
+            }] } });
 let XplPagination = class XplPagination {
     constructor(c, r, z) {
         this.z = z;
@@ -1203,29 +1374,31 @@ let XplPagination = class XplPagination {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplPagination.prototype, "pageChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplPagination.prototype, "rowsPerPageChange", void 0);
+XplPagination.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPagination, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplPagination.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplPagination, isStandalone: true, selector: "xpl-pagination", inputs: { currentPage: "currentPage", rowsPerPageOptions: "rowsPerPageOptions", selectedRowsPerPage: "selectedRowsPerPage", totalPages: "totalPages", withPageControl: "withPageControl" }, outputs: { pageChange: "pageChange", rowsPerPageChange: "rowsPerPageChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplPagination = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplPagination,
         inputs: ['currentPage', 'rowsPerPageOptions', 'selectedRowsPerPage', 'totalPages', 'withPageControl']
     }),
-    Component({
-        selector: 'xpl-pagination',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['currentPage', 'rowsPerPageOptions', 'selectedRowsPerPage', 'totalPages', 'withPageControl'],
-        outputs: ['pageChange', 'rowsPerPageChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplPagination);
 export { XplPagination };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPagination, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-pagination',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['currentPage', 'rowsPerPageOptions', 'selectedRowsPerPage', 'totalPages', 'withPageControl'],
+                    outputs: ['pageChange', 'rowsPerPageChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { pageChange: [{
+                type: Output
+            }], rowsPerPageChange: [{
+                type: Output
+            }] } });
 let XplPanel = class XplPanel {
     constructor(c, r, z) {
         this.z = z;
@@ -1233,20 +1406,26 @@ let XplPanel = class XplPanel {
         this.el = r.nativeElement;
     }
 };
+XplPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplPanel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplPanel, isStandalone: true, selector: "xpl-panel", inputs: { accent: "accent", padding: "padding" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplPanel = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplPanel,
         inputs: ['accent', 'padding']
     }),
-    Component({
-        selector: 'xpl-panel',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['accent', 'padding'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplPanel);
 export { XplPanel };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['accent', 'padding'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplPopover = class XplPopover {
     constructor(c, r, z) {
         this.z = z;
@@ -1255,25 +1434,29 @@ let XplPopover = class XplPopover {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplPopover.prototype, "isOpenChange", void 0);
+XplPopover.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPopover, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplPopover.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplPopover, isStandalone: true, selector: "xpl-popover", inputs: { disabled: "disabled", display: "display", isOpen: "isOpen", position: "position" }, outputs: { isOpenChange: "isOpenChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplPopover = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplPopover,
         inputs: ['disabled', 'display', 'isOpen', 'position']
     }),
-    Component({
-        selector: 'xpl-popover',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'display', 'isOpen', 'position'],
-        outputs: ['isOpenChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplPopover);
 export { XplPopover };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplPopover, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-popover',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'display', 'isOpen', 'position'],
+                    outputs: ['isOpenChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { isOpenChange: [{
+                type: Output
+            }] } });
 let XplProgressBar = class XplProgressBar {
     constructor(c, r, z) {
         this.z = z;
@@ -1281,20 +1464,26 @@ let XplProgressBar = class XplProgressBar {
         this.el = r.nativeElement;
     }
 };
+XplProgressBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplProgressBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplProgressBar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplProgressBar, isStandalone: true, selector: "xpl-progress-bar", inputs: { helperText: "helperText", label: "label", max: "max", size: "size", value: "value", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplProgressBar = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplProgressBar,
         inputs: ['helperText', 'label', 'max', 'size', 'value', 'variant']
     }),
-    Component({
-        selector: 'xpl-progress-bar',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['helperText', 'label', 'max', 'size', 'value', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplProgressBar);
 export { XplProgressBar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplProgressBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-progress-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['helperText', 'label', 'max', 'size', 'value', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplProgressIndicator = class XplProgressIndicator {
     constructor(c, r, z) {
         this.z = z;
@@ -1302,20 +1491,26 @@ let XplProgressIndicator = class XplProgressIndicator {
         this.el = r.nativeElement;
     }
 };
+XplProgressIndicator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplProgressIndicator, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplProgressIndicator.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplProgressIndicator, isStandalone: true, selector: "xpl-progress-indicator", inputs: { currentStep: "currentStep", layout: "layout", showLabels: "showLabels", showNumbers: "showNumbers", steps: "steps" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplProgressIndicator = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplProgressIndicator,
         inputs: ['currentStep', 'layout', 'showLabels', 'showNumbers', 'steps']
     }),
-    Component({
-        selector: 'xpl-progress-indicator',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['currentStep', 'layout', 'showLabels', 'showNumbers', 'steps'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplProgressIndicator);
 export { XplProgressIndicator };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplProgressIndicator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-progress-indicator',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['currentStep', 'layout', 'showLabels', 'showNumbers', 'steps'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplRadio = class XplRadio {
     constructor(c, r, z) {
         this.z = z;
@@ -1324,25 +1519,29 @@ let XplRadio = class XplRadio {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplRadio.prototype, "radioChange", void 0);
+XplRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplRadio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplRadio.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplRadio, isStandalone: true, selector: "xpl-radio", inputs: { checked: "checked", description: "description", disabled: "disabled", name: "name", required: "required", selectedValue: "selectedValue", styled: "styled", value: "value" }, outputs: { radioChange: "radioChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplRadio = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplRadio,
         inputs: ['checked', 'description', 'disabled', 'name', 'required', 'selectedValue', 'styled', 'value']
     }),
-    Component({
-        selector: 'xpl-radio',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['checked', 'description', 'disabled', 'name', 'required', 'selectedValue', 'styled', 'value'],
-        outputs: ['radioChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplRadio);
 export { XplRadio };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplRadio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-radio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'description', 'disabled', 'name', 'required', 'selectedValue', 'styled', 'value'],
+                    outputs: ['radioChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { radioChange: [{
+                type: Output
+            }] } });
 let XplSecondaryNav = class XplSecondaryNav {
     constructor(c, r, z) {
         this.z = z;
@@ -1350,19 +1549,25 @@ let XplSecondaryNav = class XplSecondaryNav {
         this.el = r.nativeElement;
     }
 };
+XplSecondaryNav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSecondaryNav, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSecondaryNav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSecondaryNav, isStandalone: true, selector: "xpl-secondary-nav", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSecondaryNav = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSecondaryNav
     }),
-    Component({
-        selector: 'xpl-secondary-nav',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSecondaryNav);
 export { XplSecondaryNav };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSecondaryNav, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-secondary-nav',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplSelect = class XplSelect {
     constructor(c, r, z) {
         this.z = z;
@@ -1374,38 +1579,36 @@ let XplSelect = class XplSelect {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSelect.prototype, "selectChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSelect.prototype, "changeEvent", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSelect.prototype, "dropdownStateChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSelect.prototype, "triggerDropdown", void 0);
+XplSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSelect, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSelect, isStandalone: true, selector: "xpl-select", inputs: { choices: "choices", classNames: "classNames", customDisplayValue: "customDisplayValue", description: "description", disabled: "disabled", dropdownFlipFallbackPlacements: "dropdownFlipFallbackPlacements", dropdownPlacement: "dropdownPlacement", error: "error", label: "label", mode: "mode", name: "name", placeholder: "placeholder", selectIcon: "selectIcon", selectedValues: "selectedValues", truncate: "truncate" }, outputs: { selectChange: "selectChange", changeEvent: "changeEvent", dropdownStateChange: "dropdownStateChange", triggerDropdown: "triggerDropdown" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSelect = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSelect,
         inputs: ['choices', 'classNames', 'customDisplayValue', 'description', 'disabled', 'dropdownFlipFallbackPlacements', 'dropdownPlacement', 'error', 'label', 'mode', 'name', 'placeholder', 'selectIcon', 'selectedValues', 'truncate'],
         methods: ['reset']
     }),
-    Component({
-        selector: 'xpl-select',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['choices', 'classNames', 'customDisplayValue', 'description', 'disabled', 'dropdownFlipFallbackPlacements', 'dropdownPlacement', 'error', 'label', 'mode', 'name', 'placeholder', 'selectIcon', 'selectedValues', 'truncate'],
-        outputs: ['selectChange', 'changeEvent', 'dropdownStateChange', 'triggerDropdown'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSelect);
 export { XplSelect };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-select',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['choices', 'classNames', 'customDisplayValue', 'description', 'disabled', 'dropdownFlipFallbackPlacements', 'dropdownPlacement', 'error', 'label', 'mode', 'name', 'placeholder', 'selectIcon', 'selectedValues', 'truncate'],
+                    outputs: ['selectChange', 'changeEvent', 'dropdownStateChange', 'triggerDropdown'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { selectChange: [{
+                type: Output
+            }], changeEvent: [{
+                type: Output
+            }], dropdownStateChange: [{
+                type: Output
+            }], triggerDropdown: [{
+                type: Output
+            }] } });
 let XplSideNav = class XplSideNav {
     constructor(c, r, z) {
         this.z = z;
@@ -1414,26 +1617,30 @@ let XplSideNav = class XplSideNav {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSideNav.prototype, "openChange", void 0);
+XplSideNav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNav, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSideNav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSideNav, isStandalone: true, selector: "xpl-side-nav", inputs: { label: "label", open: "open" }, outputs: { openChange: "openChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSideNav = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSideNav,
         inputs: ['label', 'open'],
         methods: ['toggle', 'setOpen']
     }),
-    Component({
-        selector: 'xpl-side-nav',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['label', 'open'],
-        outputs: ['openChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSideNav);
 export { XplSideNav };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNav, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-side-nav',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['label', 'open'],
+                    outputs: ['openChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { openChange: [{
+                type: Output
+            }] } });
 let XplSideNavHeaderItem = class XplSideNavHeaderItem {
     constructor(c, r, z) {
         this.z = z;
@@ -1442,25 +1649,29 @@ let XplSideNavHeaderItem = class XplSideNavHeaderItem {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSideNavHeaderItem.prototype, "navigate", void 0);
+XplSideNavHeaderItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavHeaderItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSideNavHeaderItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSideNavHeaderItem, isStandalone: true, selector: "xpl-side-nav-header-item", inputs: { icon: "icon", label: "label", selected: "selected", type: "type" }, outputs: { navigate: "navigate" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSideNavHeaderItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSideNavHeaderItem,
         inputs: ['icon', 'label', 'selected', 'type']
     }),
-    Component({
-        selector: 'xpl-side-nav-header-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['icon', 'label', 'selected', 'type'],
-        outputs: ['navigate'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSideNavHeaderItem);
 export { XplSideNavHeaderItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavHeaderItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-side-nav-header-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['icon', 'label', 'selected', 'type'],
+                    outputs: ['navigate'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { navigate: [{
+                type: Output
+            }] } });
 let XplSideNavItem = class XplSideNavItem {
     constructor(c, r, z) {
         this.z = z;
@@ -1470,29 +1681,31 @@ let XplSideNavItem = class XplSideNavItem {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSideNavItem.prototype, "expandedChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSideNavItem.prototype, "navigate", void 0);
+XplSideNavItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSideNavItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSideNavItem, isStandalone: true, selector: "xpl-side-nav-item", inputs: { disabled: "disabled", expanded: "expanded", hasChildren: "hasChildren", hidden: "hidden", icon: "icon", label: "label", link: "link", selected: "selected" }, outputs: { expandedChange: "expandedChange", navigate: "navigate" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSideNavItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSideNavItem,
         inputs: ['disabled', 'expanded', 'hasChildren', 'hidden', 'icon', 'label', 'link', 'selected']
     }),
-    Component({
-        selector: 'xpl-side-nav-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'expanded', 'hasChildren', 'hidden', 'icon', 'label', 'link', 'selected'],
-        outputs: ['expandedChange', 'navigate'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSideNavItem);
 export { XplSideNavItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-side-nav-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'expanded', 'hasChildren', 'hidden', 'icon', 'label', 'link', 'selected'],
+                    outputs: ['expandedChange', 'navigate'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { expandedChange: [{
+                type: Output
+            }], navigate: [{
+                type: Output
+            }] } });
 let XplSideNavSection = class XplSideNavSection {
     constructor(c, r, z) {
         this.z = z;
@@ -1501,25 +1714,29 @@ let XplSideNavSection = class XplSideNavSection {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSideNavSection.prototype, "expandedChange", void 0);
+XplSideNavSection.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavSection, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSideNavSection.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSideNavSection, isStandalone: true, selector: "xpl-side-nav-section", inputs: { collapsible: "collapsible", expanded: "expanded", heading: "heading" }, outputs: { expandedChange: "expandedChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSideNavSection = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSideNavSection,
         inputs: ['collapsible', 'expanded', 'heading']
     }),
-    Component({
-        selector: 'xpl-side-nav-section',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['collapsible', 'expanded', 'heading'],
-        outputs: ['expandedChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSideNavSection);
 export { XplSideNavSection };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSideNavSection, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-side-nav-section',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['collapsible', 'expanded', 'heading'],
+                    outputs: ['expandedChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { expandedChange: [{
+                type: Output
+            }] } });
 let XplSkeleton = class XplSkeleton {
     constructor(c, r, z) {
         this.z = z;
@@ -1527,20 +1744,26 @@ let XplSkeleton = class XplSkeleton {
         this.el = r.nativeElement;
     }
 };
+XplSkeleton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSkeleton, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSkeleton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSkeleton, isStandalone: true, selector: "xpl-skeleton", inputs: { classNames: "classNames", fullWidth: "fullWidth", height: "height", margin: "margin", shape: "shape", size: "size", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSkeleton = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSkeleton,
         inputs: ['classNames', 'fullWidth', 'height', 'margin', 'shape', 'size', 'width']
     }),
-    Component({
-        selector: 'xpl-skeleton',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['classNames', 'fullWidth', 'height', 'margin', 'shape', 'size', 'width'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSkeleton);
 export { XplSkeleton };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSkeleton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-skeleton',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['classNames', 'fullWidth', 'height', 'margin', 'shape', 'size', 'width'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplSlideout = class XplSlideout {
     constructor(c, r, z) {
         this.z = z;
@@ -1549,25 +1772,29 @@ let XplSlideout = class XplSlideout {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSlideout.prototype, "isOpenChange", void 0);
+XplSlideout.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSlideout, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSlideout.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSlideout, isStandalone: true, selector: "xpl-slideout", inputs: { backdrop: "backdrop", isOpen: "isOpen", showFooter: "showFooter", variant: "variant" }, outputs: { isOpenChange: "isOpenChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSlideout = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSlideout,
         inputs: ['backdrop', 'isOpen', 'showFooter', 'variant']
     }),
-    Component({
-        selector: 'xpl-slideout',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['backdrop', 'isOpen', 'showFooter', 'variant'],
-        outputs: ['isOpenChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSlideout);
 export { XplSlideout };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSlideout, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-slideout',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['backdrop', 'isOpen', 'showFooter', 'variant'],
+                    outputs: ['isOpenChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { isOpenChange: [{
+                type: Output
+            }] } });
 let XplSpotlight = class XplSpotlight {
     constructor(c, r, z) {
         this.z = z;
@@ -1579,37 +1806,35 @@ let XplSpotlight = class XplSpotlight {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSpotlight.prototype, "dismiss", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSpotlight.prototype, "primaryAction", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSpotlight.prototype, "secondaryAction", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplSpotlight.prototype, "targetClick", void 0);
+XplSpotlight.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSpotlight, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplSpotlight.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplSpotlight, isStandalone: true, selector: "xpl-spotlight", inputs: { actionLayout: "actionLayout", anchorPosition: "anchorPosition", body: "body", currentStep: "currentStep", heading: "heading", isDismissible: "isDismissible", isOpen: "isOpen", primaryActionLabel: "primaryActionLabel", secondaryActionLabel: "secondaryActionLabel", showActions: "showActions", showImage: "showImage", showSteps: "showSteps", target: "target", totalSteps: "totalSteps" }, outputs: { dismiss: "dismiss", primaryAction: "primaryAction", secondaryAction: "secondaryAction", targetClick: "targetClick" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplSpotlight = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplSpotlight,
         inputs: ['actionLayout', 'anchorPosition', 'body', 'currentStep', 'heading', 'isDismissible', 'isOpen', 'primaryActionLabel', 'secondaryActionLabel', 'showActions', 'showImage', 'showSteps', 'target', 'totalSteps']
     }),
-    Component({
-        selector: 'xpl-spotlight',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['actionLayout', 'anchorPosition', 'body', 'currentStep', 'heading', 'isDismissible', 'isOpen', 'primaryActionLabel', 'secondaryActionLabel', 'showActions', 'showImage', 'showSteps', 'target', 'totalSteps'],
-        outputs: ['dismiss', 'primaryAction', 'secondaryAction', 'targetClick'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplSpotlight);
 export { XplSpotlight };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplSpotlight, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-spotlight',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['actionLayout', 'anchorPosition', 'body', 'currentStep', 'heading', 'isDismissible', 'isOpen', 'primaryActionLabel', 'secondaryActionLabel', 'showActions', 'showImage', 'showSteps', 'target', 'totalSteps'],
+                    outputs: ['dismiss', 'primaryAction', 'secondaryAction', 'targetClick'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { dismiss: [{
+                type: Output
+            }], primaryAction: [{
+                type: Output
+            }], secondaryAction: [{
+                type: Output
+            }], targetClick: [{
+                type: Output
+            }] } });
 let XplTab = class XplTab {
     constructor(c, r, z) {
         this.z = z;
@@ -1618,25 +1843,29 @@ let XplTab = class XplTab {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTab.prototype, "tabChange", void 0);
+XplTab.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTab, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTab.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTab, isStandalone: true, selector: "xpl-tab", inputs: { badge: "badge", badgeVariant: "badgeVariant", disabled: "disabled", groupDisabled: "groupDisabled", icon: "icon", iconPosition: "iconPosition", selected: "selected", target: "target" }, outputs: { tabChange: "tabChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTab = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTab,
         inputs: ['badge', 'badgeVariant', 'disabled', 'groupDisabled', 'icon', 'iconPosition', 'selected', 'target']
     }),
-    Component({
-        selector: 'xpl-tab',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['badge', 'badgeVariant', 'disabled', 'groupDisabled', 'icon', 'iconPosition', 'selected', 'target'],
-        outputs: ['tabChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTab);
 export { XplTab };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTab, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-tab',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['badge', 'badgeVariant', 'disabled', 'groupDisabled', 'icon', 'iconPosition', 'selected', 'target'],
+                    outputs: ['tabChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { tabChange: [{
+                type: Output
+            }] } });
 let XplTabPanel = class XplTabPanel {
     constructor(c, r, z) {
         this.z = z;
@@ -1644,20 +1873,26 @@ let XplTabPanel = class XplTabPanel {
         this.el = r.nativeElement;
     }
 };
+XplTabPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTabPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTabPanel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTabPanel, isStandalone: true, selector: "xpl-tab-panel", inputs: { selected: "selected", target: "target" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTabPanel = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTabPanel,
         inputs: ['selected', 'target']
     }),
-    Component({
-        selector: 'xpl-tab-panel',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['selected', 'target'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTabPanel);
 export { XplTabPanel };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTabPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-tab-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['selected', 'target'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTable = class XplTable {
     constructor(c, r, z) {
         this.z = z;
@@ -1669,37 +1904,35 @@ let XplTable = class XplTable {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTable.prototype, "rowOrderChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTable.prototype, "rowSelectionChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTable.prototype, "sortChanged", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTable.prototype, "tableSelect", void 0);
+XplTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTable, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTable.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTable, isStandalone: true, selector: "xpl-table", inputs: { columns: "columns", data: "data", footer: "footer", freeze: "freeze", isSortable: "isSortable", label: "label", multiselect: "multiselect", reorderHandleIcon: "reorderHandleIcon", reorderHandleIconKeyboard: "reorderHandleIconKeyboard", rowReorderable: "rowReorderable", selectable: "selectable", selectedValues: "selectedValues", sortableColumns: "sortableColumns", striped: "striped" }, outputs: { rowOrderChange: "rowOrderChange", rowSelectionChange: "rowSelectionChange", sortChanged: "sortChanged", tableSelect: "tableSelect" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTable = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTable,
         inputs: ['columns', 'data', 'footer', 'freeze', 'isSortable', 'label', 'multiselect', 'reorderHandleIcon', 'reorderHandleIconKeyboard', 'rowReorderable', 'selectable', 'selectedValues', 'sortableColumns', 'striped']
     }),
-    Component({
-        selector: 'xpl-table',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['columns', 'data', 'footer', 'freeze', 'isSortable', 'label', 'multiselect', 'reorderHandleIcon', 'reorderHandleIconKeyboard', 'rowReorderable', 'selectable', 'selectedValues', 'sortableColumns', 'striped'],
-        outputs: ['rowOrderChange', 'rowSelectionChange', 'sortChanged', 'tableSelect'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTable);
 export { XplTable };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTable, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['columns', 'data', 'footer', 'freeze', 'isSortable', 'label', 'multiselect', 'reorderHandleIcon', 'reorderHandleIconKeyboard', 'rowReorderable', 'selectable', 'selectedValues', 'sortableColumns', 'striped'],
+                    outputs: ['rowOrderChange', 'rowSelectionChange', 'sortChanged', 'tableSelect'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { rowOrderChange: [{
+                type: Output
+            }], rowSelectionChange: [{
+                type: Output
+            }], sortChanged: [{
+                type: Output
+            }], tableSelect: [{
+                type: Output
+            }] } });
 let XplTableBody = class XplTableBody {
     constructor(c, r, z) {
         this.z = z;
@@ -1707,19 +1940,25 @@ let XplTableBody = class XplTableBody {
         this.el = r.nativeElement;
     }
 };
+XplTableBody.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableBody, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableBody.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableBody, isStandalone: true, selector: "xpl-table-body", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableBody = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableBody
     }),
-    Component({
-        selector: 'xpl-table-body',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableBody);
 export { XplTableBody };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableBody, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-body',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTableCell = class XplTableCell {
     constructor(c, r, z) {
         this.z = z;
@@ -1727,20 +1966,26 @@ let XplTableCell = class XplTableCell {
         this.el = r.nativeElement;
     }
 };
+XplTableCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableCell, isStandalone: true, selector: "xpl-table-cell", inputs: { align: "align", bold: "bold", disabled: "disabled", underline: "underline" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableCell = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableCell,
         inputs: ['align', 'bold', 'disabled', 'underline']
     }),
-    Component({
-        selector: 'xpl-table-cell',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['align', 'bold', 'disabled', 'underline'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableCell);
 export { XplTableCell };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['align', 'bold', 'disabled', 'underline'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTableFooter = class XplTableFooter {
     constructor(c, r, z) {
         this.z = z;
@@ -1748,19 +1993,25 @@ let XplTableFooter = class XplTableFooter {
         this.el = r.nativeElement;
     }
 };
+XplTableFooter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableFooter, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableFooter.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableFooter, isStandalone: true, selector: "xpl-table-footer", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableFooter = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableFooter
     }),
-    Component({
-        selector: 'xpl-table-footer',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableFooter);
 export { XplTableFooter };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableFooter, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-footer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTableFooterCell = class XplTableFooterCell {
     constructor(c, r, z) {
         this.z = z;
@@ -1768,20 +2019,26 @@ let XplTableFooterCell = class XplTableFooterCell {
         this.el = r.nativeElement;
     }
 };
+XplTableFooterCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableFooterCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableFooterCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableFooterCell, isStandalone: true, selector: "xpl-table-footer-cell", inputs: { align: "align" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableFooterCell = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableFooterCell,
         inputs: ['align']
     }),
-    Component({
-        selector: 'xpl-table-footer-cell',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['align'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableFooterCell);
 export { XplTableFooterCell };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableFooterCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-footer-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['align'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTableHeader = class XplTableHeader {
     constructor(c, r, z) {
         this.z = z;
@@ -1789,19 +2046,25 @@ let XplTableHeader = class XplTableHeader {
         this.el = r.nativeElement;
     }
 };
+XplTableHeader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableHeader, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableHeader.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableHeader, isStandalone: true, selector: "xpl-table-header", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableHeader = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableHeader
     }),
-    Component({
-        selector: 'xpl-table-header',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: [],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableHeader);
 export { XplTableHeader };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableHeader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-header',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: [],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTableHeaderCell = class XplTableHeaderCell {
     constructor(c, r, z) {
         this.z = z;
@@ -1811,29 +2074,31 @@ let XplTableHeaderCell = class XplTableHeaderCell {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTableHeaderCell.prototype, "headerCheckboxChange", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTableHeaderCell.prototype, "headerSortChange", void 0);
+XplTableHeaderCell.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableHeaderCell, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableHeaderCell.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableHeaderCell, isStandalone: true, selector: "xpl-table-header-cell", inputs: { align: "align", checkboxAriaLabel: "checkboxAriaLabel", checked: "checked", columnWidth: "columnWidth", icon: "icon", indeterminate: "indeterminate", label: "label", sortDirection: "sortDirection", sortKey: "sortKey", sortable: "sortable", type: "type", width: "width" }, outputs: { headerCheckboxChange: "headerCheckboxChange", headerSortChange: "headerSortChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableHeaderCell = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableHeaderCell,
         inputs: ['align', 'checkboxAriaLabel', 'checked', 'columnWidth', 'icon', 'indeterminate', 'label', 'sortDirection', 'sortKey', 'sortable', 'type', 'width']
     }),
-    Component({
-        selector: 'xpl-table-header-cell',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['align', 'checkboxAriaLabel', 'checked', 'columnWidth', 'icon', 'indeterminate', 'label', 'sortDirection', 'sortKey', 'sortable', 'type', 'width'],
-        outputs: ['headerCheckboxChange', 'headerSortChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableHeaderCell);
 export { XplTableHeaderCell };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableHeaderCell, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-header-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['align', 'checkboxAriaLabel', 'checked', 'columnWidth', 'icon', 'indeterminate', 'label', 'sortDirection', 'sortKey', 'sortable', 'type', 'width'],
+                    outputs: ['headerCheckboxChange', 'headerSortChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { headerCheckboxChange: [{
+                type: Output
+            }], headerSortChange: [{
+                type: Output
+            }] } });
 let XplTableRow = class XplTableRow {
     constructor(c, r, z) {
         this.z = z;
@@ -1841,20 +2106,26 @@ let XplTableRow = class XplTableRow {
         this.el = r.nativeElement;
     }
 };
+XplTableRow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableRow, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTableRow.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTableRow, isStandalone: true, selector: "xpl-table-row", inputs: { disabled: "disabled", rowId: "rowId", selected: "selected" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTableRow = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTableRow,
         inputs: ['disabled', 'rowId', 'selected']
     }),
-    Component({
-        selector: 'xpl-table-row',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'rowId', 'selected'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTableRow);
 export { XplTableRow };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTableRow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-table-row',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'rowId', 'selected'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTabs = class XplTabs {
     constructor(c, r, z) {
         this.z = z;
@@ -1863,25 +2134,29 @@ let XplTabs = class XplTabs {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTabs.prototype, "tabChange", void 0);
+XplTabs.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTabs, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTabs.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTabs, isStandalone: true, selector: "xpl-tabs", inputs: { disabled: "disabled", fullWidth: "fullWidth", type: "type", value: "value" }, outputs: { tabChange: "tabChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTabs = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTabs,
         inputs: ['disabled', 'fullWidth', 'type', 'value']
     }),
-    Component({
-        selector: 'xpl-tabs',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'fullWidth', 'type', 'value'],
-        outputs: ['tabChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTabs);
 export { XplTabs };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTabs, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-tabs',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'fullWidth', 'type', 'value'],
+                    outputs: ['tabChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { tabChange: [{
+                type: Output
+            }] } });
 let XplTag = class XplTag {
     constructor(c, r, z) {
         this.z = z;
@@ -1893,37 +2168,35 @@ let XplTag = class XplTag {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTag.prototype, "close", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTag.prototype, "tagDragEnd", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTag.prototype, "tagDragStart", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTag.prototype, "tagRemove", void 0);
+XplTag.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTag, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTag.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTag, isStandalone: true, selector: "xpl-tag", inputs: { disabled: "disabled", dismissible: "dismissible", isDraggable: "isDraggable", size: "size", tagId: "tagId" }, outputs: { close: "close", tagDragEnd: "tagDragEnd", tagDragStart: "tagDragStart", tagRemove: "tagRemove" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTag = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTag,
         inputs: ['disabled', 'dismissible', 'isDraggable', 'size', 'tagId']
     }),
-    Component({
-        selector: 'xpl-tag',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['disabled', 'dismissible', 'isDraggable', 'size', 'tagId'],
-        outputs: ['close', 'tagDragEnd', 'tagDragStart', 'tagRemove'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTag);
 export { XplTag };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTag, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-tag',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['disabled', 'dismissible', 'isDraggable', 'size', 'tagId'],
+                    outputs: ['close', 'tagDragEnd', 'tagDragStart', 'tagRemove'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { close: [{
+                type: Output
+            }], tagDragEnd: [{
+                type: Output
+            }], tagDragStart: [{
+                type: Output
+            }], tagRemove: [{
+                type: Output
+            }] } });
 let XplToast = class XplToast {
     constructor(c, r, z) {
         this.z = z;
@@ -1931,20 +2204,26 @@ let XplToast = class XplToast {
         this.el = r.nativeElement;
     }
 };
+XplToast.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToast, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplToast.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplToast, isStandalone: true, selector: "xpl-toast", inputs: { caption: "caption", dismissable: "dismissable", dismissible: "dismissible", showIcon: "showIcon", timeout: "timeout", variant: "variant" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplToast = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplToast,
         inputs: ['caption', 'dismissable', 'dismissible', 'showIcon', 'timeout', 'variant']
     }),
-    Component({
-        selector: 'xpl-toast',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['caption', 'dismissable', 'dismissible', 'showIcon', 'timeout', 'variant'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplToast);
 export { XplToast };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToast, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-toast',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['caption', 'dismissable', 'dismissible', 'showIcon', 'timeout', 'variant'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplToggle = class XplToggle {
     constructor(c, r, z) {
         this.z = z;
@@ -1953,25 +2232,29 @@ let XplToggle = class XplToggle {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplToggle.prototype, "toggleChange", void 0);
+XplToggle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToggle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplToggle.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplToggle, isStandalone: true, selector: "xpl-toggle", inputs: { checked: "checked", description: "description", disabled: "disabled", heading: "heading", label: "label", name: "name", variant: "variant" }, outputs: { toggleChange: "toggleChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplToggle = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplToggle,
         inputs: ['checked', 'description', 'disabled', 'heading', 'label', 'name', 'variant']
     }),
-    Component({
-        selector: 'xpl-toggle',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['checked', 'description', 'disabled', 'heading', 'label', 'name', 'variant'],
-        outputs: ['toggleChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplToggle);
 export { XplToggle };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToggle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-toggle',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['checked', 'description', 'disabled', 'heading', 'label', 'name', 'variant'],
+                    outputs: ['toggleChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { toggleChange: [{
+                type: Output
+            }] } });
 let XplToolbar = class XplToolbar {
     constructor(c, r, z) {
         this.z = z;
@@ -1979,20 +2262,26 @@ let XplToolbar = class XplToolbar {
         this.el = r.nativeElement;
     }
 };
+XplToolbar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToolbar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplToolbar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplToolbar, isStandalone: true, selector: "xpl-toolbar", inputs: { selectedItemCount: "selectedItemCount" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplToolbar = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplToolbar,
         inputs: ['selectedItemCount']
     }),
-    Component({
-        selector: 'xpl-toolbar',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['selectedItemCount'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplToolbar);
 export { XplToolbar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplToolbar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-toolbar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['selectedItemCount'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTooltip = class XplTooltip {
     constructor(c, r, z) {
         this.z = z;
@@ -2000,20 +2289,26 @@ let XplTooltip = class XplTooltip {
         this.el = r.nativeElement;
     }
 };
+XplTooltip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTooltip, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTooltip.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTooltip, isStandalone: true, selector: "xpl-tooltip", inputs: { hideArrow: "hideArrow", position: "position", text: "text" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTooltip = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTooltip,
         inputs: ['hideArrow', 'position', 'text']
     }),
-    Component({
-        selector: 'xpl-tooltip',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['hideArrow', 'position', 'text'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTooltip);
 export { XplTooltip };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTooltip, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-tooltip',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['hideArrow', 'position', 'text'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplTopNav = class XplTopNav {
     constructor(c, r, z) {
         this.z = z;
@@ -2023,29 +2318,31 @@ let XplTopNav = class XplTopNav {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTopNav.prototype, "brandClick", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTopNav.prototype, "navOpen", void 0);
+XplTopNav.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNav, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTopNav.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTopNav, isStandalone: true, selector: "xpl-top-nav", inputs: { brandHref: "brandHref", brandLogo: "brandLogo", brandName: "brandName", childAccountLabel: "childAccountLabel", label: "label", navControl: "navControl" }, outputs: { brandClick: "brandClick", navOpen: "navOpen" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTopNav = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTopNav,
         inputs: ['brandHref', 'brandLogo', 'brandName', 'childAccountLabel', 'label', 'navControl']
     }),
-    Component({
-        selector: 'xpl-top-nav',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['brandHref', 'brandLogo', 'brandName', 'childAccountLabel', 'label', 'navControl'],
-        outputs: ['brandClick', 'navOpen'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTopNav);
 export { XplTopNav };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNav, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-top-nav',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['brandHref', 'brandLogo', 'brandName', 'childAccountLabel', 'label', 'navControl'],
+                    outputs: ['brandClick', 'navOpen'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { brandClick: [{
+                type: Output
+            }], navOpen: [{
+                type: Output
+            }] } });
 let XplTopNavItem = class XplTopNavItem {
     constructor(c, r, z) {
         this.z = z;
@@ -2055,30 +2352,32 @@ let XplTopNavItem = class XplTopNavItem {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTopNavItem.prototype, "navItemClick", void 0);
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplTopNavItem.prototype, "openChange", void 0);
+XplTopNavItem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNavItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTopNavItem.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTopNavItem, isStandalone: true, selector: "xpl-top-nav-item", inputs: { active: "active", description: "description", href: "href", icon: "icon", itemAriaLabel: "itemAriaLabel", label: "label", open: "open", openMode: "openMode", selected: "selected" }, outputs: { navItemClick: "navItemClick", openChange: "openChange" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTopNavItem = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTopNavItem,
         inputs: ['active', 'description', 'href', 'icon', 'itemAriaLabel', 'label', 'open', 'openMode', 'selected'],
         methods: ['closeMenu', 'openMenu', 'toggleMenu']
     }),
-    Component({
-        selector: 'xpl-top-nav-item',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['active', 'description', 'href', 'icon', 'itemAriaLabel', 'label', 'open', 'openMode', 'selected'],
-        outputs: ['navItemClick', 'openChange'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTopNavItem);
 export { XplTopNavItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNavItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-top-nav-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['active', 'description', 'href', 'icon', 'itemAriaLabel', 'label', 'open', 'openMode', 'selected'],
+                    outputs: ['navItemClick', 'openChange'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { navItemClick: [{
+                type: Output
+            }], openChange: [{
+                type: Output
+            }] } });
 let XplTopNavMenu = class XplTopNavMenu {
     constructor(c, r, z) {
         this.z = z;
@@ -2086,20 +2385,26 @@ let XplTopNavMenu = class XplTopNavMenu {
         this.el = r.nativeElement;
     }
 };
+XplTopNavMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNavMenu, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplTopNavMenu.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplTopNavMenu, isStandalone: true, selector: "xpl-top-nav-menu", inputs: { label: "label" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplTopNavMenu = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplTopNavMenu,
         inputs: ['label']
     }),
-    Component({
-        selector: 'xpl-top-nav-menu',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['label'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplTopNavMenu);
 export { XplTopNavMenu };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplTopNavMenu, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-top-nav-menu',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['label'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });
 let XplUtilityBar = class XplUtilityBar {
     constructor(c, r, z) {
         this.z = z;
@@ -2108,23 +2413,27 @@ let XplUtilityBar = class XplUtilityBar {
         this.el = r.nativeElement;
     }
 };
-__decorate([
-    Output(),
-    __metadata("design:type", Object)
-], XplUtilityBar.prototype, "navOpen", void 0);
+XplUtilityBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplUtilityBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+XplUtilityBar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.25", type: XplUtilityBar, isStandalone: true, selector: "xpl-utility-bar", inputs: { isNavOpenAtStartup: "isNavOpenAtStartup", navControl: "navControl" }, outputs: { navOpen: "navOpen" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 XplUtilityBar = __decorate([
     ProxyCmp({
         defineCustomElementFn: defineXplUtilityBar,
         inputs: ['isNavOpenAtStartup', 'navControl']
     }),
-    Component({
-        selector: 'xpl-utility-bar',
-        changeDetection: ChangeDetectionStrategy.OnPush,
-        template: '<ng-content></ng-content>',
-        inputs: ['isNavOpenAtStartup', 'navControl'],
-        outputs: ['navOpen'],
-    }),
     __metadata("design:paramtypes", [ChangeDetectorRef, ElementRef, NgZone])
 ], XplUtilityBar);
 export { XplUtilityBar };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: XplUtilityBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'xpl-utility-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    inputs: ['isNavOpenAtStartup', 'navControl'],
+                    outputs: ['navOpen'],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { navOpen: [{
+                type: Output
+            }] } });
 //# sourceMappingURL=proxies.js.map